aswi2022code-of-duty-gitlab/backend/src/test/java/cz/zcu/kiv/backendapi/catalog/CatalogItemServiceImplTest.java @ cf12d561

package cz.zcu.kiv.backendapi.catalog;

import cz.zcu.kiv.backendapi.alternativename.CatalogItemName;
import cz.zcu.kiv.backendapi.bibliography.Bibliography;
import cz.zcu.kiv.backendapi.country.Country;
import cz.zcu.kiv.backendapi.exception.ApiRequestException;
import cz.zcu.kiv.backendapi.path.PathDto;
import cz.zcu.kiv.backendapi.type.Type;
import cz.zcu.kiv.backendapi.type.TypeServiceImpl;
import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

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.BDDMockito.given;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;

@ExtendWith(MockitoExtension.class)
class CatalogItemServiceImplTest {

    @Mock
    private CatalogItemRepository catalogItemRepository;

    @Mock
    private TypeServiceImpl typeService;

    private CatalogItemServiceImpl underTest;

    @BeforeEach
    void setUp() {
        underTest = new CatalogItemServiceImpl(catalogItemRepository, typeService);
    }

    @Test
    void saveCatalog() {
        // given
        Type type = new Type("type");

        CatalogItem catalogItem = new CatalogItem();
        catalogItem.setName("aaacbbbbbbbaa");
        catalogItem.setBibliography(Stream.of(new Bibliography("bibl", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setTypes(Stream.of(type).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setAllNames(Stream.of(new CatalogItemName("altName", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCountries(Stream.of(new Country("aaaabbaa", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setWrittenForms(Stream.of(new WrittenForm("written", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCertainty(0);
        catalogItem.setLatitude(0.1);
        catalogItem.setLongitude(0.2);

        CatalogItem catalogItem2 = new CatalogItem();
        catalogItem2.setName("name");
        catalogItem2.setBibliography(Stream.of(new Bibliography("bibl", catalogItem2, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setTypes(Stream.of(type).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setAllNames(Stream.of(new CatalogItemName("aaaabbbbbbaa", catalogItem2, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setCountries(Stream.of(new Country("aaaabbcccefaa", catalogItem2, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setWrittenForms(Stream.of(new WrittenForm("written", catalogItem2, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setCertainty(1);
        catalogItem2.setLatitude(1.1);
        catalogItem2.setLongitude(1.2);

        List<CatalogItem> catalog = List.of(catalogItem, catalogItem2);

        given(typeService.getTypeByName(anyString())).willReturn(Optional.of(type));

        // when
        underTest.saveCatalog(catalog);

        // then
        verify(typeService, never()).saveType(type);
        verify(catalogItemRepository).save(catalogItem);
        verify(catalogItemRepository).save(catalogItem2);
    }

    @Test
    void testSaveCatalogItem() {
        // given
        CatalogItemDto catalogItemDto = new CatalogItemDto();
        catalogItemDto.setName("name");
        catalogItemDto.setBibliography(Stream.of("bibl").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setTypes(Stream.of("type").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setAllNames(Stream.of("altName").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCountries(Stream.of("country").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setWrittenForms(Stream.of("written").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCertainty(0);
        catalogItemDto.setLatitude(0.1);
        catalogItemDto.setLongitude(0.2);
        catalogItemDto.setDescription("description");

        Type type = new Type("type");

        CatalogItem catalogItem = new CatalogItem();
        catalogItem.setName("name");
        catalogItem.setBibliography(Stream.of(new Bibliography("bibl", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setTypes(Stream.of(type).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setAllNames(Stream.of(new CatalogItemName("altName", catalogItem, 1), new CatalogItemName("name", catalogItem, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCountries(Stream.of(new Country("country", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setWrittenForms(Stream.of(new WrittenForm("written", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCertainty(0);
        catalogItem.setLatitude(0.1);
        catalogItem.setLongitude(0.2);
        catalogItem.setDescription("description");

        given(typeService.getTypeByName(anyString())).willReturn(Optional.of(type));

        // when
        underTest.saveCatalogItem(catalogItemDto);

        // then
        ArgumentCaptor<CatalogItem> argumentCaptor = ArgumentCaptor.forClass(CatalogItem.class);

        verify(catalogItemRepository).save(argumentCaptor.capture());
        verify(typeService, never()).saveType(type);

        CatalogItem capturedItem = argumentCaptor.getValue();

        assertThat(capturedItem.getName()).isEqualTo(catalogItem.getName());
        assertThat(capturedItem.getLongitude()).isEqualTo(catalogItem.getLongitude());
        assertThat(capturedItem.getLatitude()).isEqualTo(catalogItem.getLatitude());
        assertThat(capturedItem.getCertainty()).isEqualTo(catalogItem.getCertainty());
        assertThat(capturedItem.getAllNames().size()).isEqualTo(catalogItem.getAllNames().size());
        assertThat(capturedItem.getBibliography().size()).isEqualTo(catalogItem.getBibliography().size());
        assertThat(capturedItem.getCountries().size()).isEqualTo(catalogItem.getCountries().size());
        assertThat(capturedItem.getWrittenForms().size()).isEqualTo(catalogItem.getWrittenForms().size());
        assertThat(capturedItem.getTypes().size()).isEqualTo(catalogItem.getTypes().size());
        assertThat(capturedItem.getDescription()).isEqualTo(catalogItem.getDescription());

    }

    @Test
    void testCanGetCatalogItem() {
        // given
        UUID id = UUID.randomUUID();
        CatalogItem catalogItem = new CatalogItem();
        catalogItem.setId(id);
        CatalogItemDto catalogItemDto = new CatalogItemDto();
        catalogItemDto.setId(id);
        given(catalogItemRepository.findById(id)).willReturn(Optional.of(catalogItem));

        // when
        CatalogItemDto retrievedItemDto = underTest.getCatalogItem(id);

        // then
        verify(catalogItemRepository).findById(id);
        assertThat(retrievedItemDto).isEqualTo(catalogItemDto);
    }

    @Test
    void testCanNotGetCatalogItem() {
        // given
        UUID id = UUID.randomUUID();

        // when
        // then
        assertThatThrownBy(() -> underTest.getCatalogItem(id))
                .isInstanceOf(ApiRequestException.class)
                .hasMessageContaining("Catalog item not found");

        verify(catalogItemRepository).findById(id);
    }

    @Test
    void testCanUpdateCatalogItem() {
        // given
        UUID id = UUID.randomUUID();

        CatalogItemDto catalogItemDto = new CatalogItemDto();
        catalogItemDto.setName("name");
        catalogItemDto.setBibliography(Stream.of("bibl").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setTypes(Stream.of("type").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setAllNames(Stream.of("altName").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCountries(Stream.of("country").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setWrittenForms(Stream.of("written").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCertainty(0);
        catalogItemDto.setLatitude(0.1);
        catalogItemDto.setLongitude(0.2);
        catalogItemDto.setDescription("description");

        Type type = new Type("type");
        Type typeOld = new Type("old");

        CatalogItem catalogItem = new CatalogItem();
        catalogItem.setId(id);
        catalogItem.setName("name");
        catalogItem.setBibliography(Stream.of(new Bibliography("bibl", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setTypes(Stream.of(type).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setAllNames(Stream.of(new CatalogItemName("altName", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCountries(Stream.of(new Country("country", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setWrittenForms(Stream.of(new WrittenForm("written", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem.setCertainty(0);
        catalogItem.setLatitude(0.1);
        catalogItem.setLongitude(0.2);
        catalogItem.setDescription("description");

        CatalogItem oldCatalogItem = new CatalogItem();
        oldCatalogItem.setId(id);
        oldCatalogItem.setName("old");
        oldCatalogItem.setBibliography(Stream.of(new Bibliography("old", oldCatalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        oldCatalogItem.setTypes(Stream.of(typeOld).collect(Collectors.toCollection(LinkedHashSet::new)));
        oldCatalogItem.setAllNames(Stream.of(new CatalogItemName("old", oldCatalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        oldCatalogItem.setCountries(Stream.of(new Country("old", oldCatalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        oldCatalogItem.setWrittenForms(Stream.of(new WrittenForm("old", catalogItem, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        oldCatalogItem.setCertainty(10);
        oldCatalogItem.setLatitude(10.1);
        oldCatalogItem.setLongitude(10.2);

        given(catalogItemRepository.findById(id)).willReturn(Optional.of(oldCatalogItem));
        given(typeService.getTypeByName(anyString())).willReturn(Optional.empty());

        // when

        underTest.updateCatalogItem(id, catalogItemDto);

        // then
        verify(typeService).saveType(type);

        ArgumentCaptor<CatalogItem> argumentCaptor = ArgumentCaptor.forClass(CatalogItem.class);

        verify(catalogItemRepository).save(argumentCaptor.capture());

        CatalogItem capturedCatalogItem = argumentCaptor.getValue();

        assertThat(capturedCatalogItem).isEqualTo(catalogItem);
        assertThat(capturedCatalogItem.getCertainty()).isEqualTo(catalogItem.getCertainty());
        assertThat(capturedCatalogItem.getLatitude()).isEqualTo(catalogItem.getLatitude());
        assertThat(capturedCatalogItem.getLongitude()).isEqualTo(catalogItem.getLongitude());
        assertThat(capturedCatalogItem.getDescription()).isEqualTo(catalogItem.getDescription());
        assertThat(capturedCatalogItem.getTypes().stream().map(Type::getType).collect(Collectors.toSet())).isEqualTo(catalogItem.getTypes().stream().map(Type::getType).collect(Collectors.toCollection(LinkedHashSet::new)));
        Set<String> alternativeNamesEntity = catalogItem.getAllNames().stream().map(CatalogItemName::getName).collect(Collectors.toCollection(LinkedHashSet::new));
        alternativeNamesEntity.add(catalogItem.getName());
        assertThat(capturedCatalogItem.getAllNames().stream().map(CatalogItemName::getName).collect(Collectors.toSet())).isEqualTo(alternativeNamesEntity);
        assertThat(capturedCatalogItem.getCountries().stream().map(Country::getName).collect(Collectors.toSet())).isEqualTo(catalogItem.getCountries().stream().map(Country::getName).collect(Collectors.toCollection(LinkedHashSet::new)));
        assertThat(capturedCatalogItem.getBibliography().stream().map(Bibliography::getSource).collect(Collectors.toSet())).isEqualTo(catalogItem.getBibliography().stream().map(Bibliography::getSource).collect(Collectors.toCollection(LinkedHashSet::new)));
        assertThat(capturedCatalogItem.getWrittenForms().stream().map(WrittenForm::getForm).collect(Collectors.toSet())).isEqualTo(catalogItem.getWrittenForms().stream().map(WrittenForm::getForm).collect(Collectors.toCollection(LinkedHashSet::new)));
    }

    @Test
    void testCanNotUpdateCatalogItem() {
        // given
        UUID id = UUID.randomUUID();

        CatalogItemDto catalogItemDto = new CatalogItemDto();
        catalogItemDto.setName("name");
        catalogItemDto.setBibliography(Stream.of("bibl").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setTypes(Stream.of("type").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setAllNames(Stream.of("altName").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCountries(Stream.of("country").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setWrittenForms(Stream.of("written").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto.setCertainty(0);
        catalogItemDto.setLatitude(0.1);
        catalogItemDto.setLongitude(0.2);

        // when
        // then
        assertThatThrownBy(() -> underTest.updateCatalogItem(id, catalogItemDto))
                .isInstanceOf(ApiRequestException.class)
                .hasMessageContaining("Catalog item not found");

        verify(catalogItemRepository, never()).save(any());
        verify(typeService, never()).saveType(any());
    }

    @Test
    void testCanDeleteCatalogItem() {
        // given
        UUID id = UUID.randomUUID();
        given(catalogItemRepository.existsById(id)).willReturn(true);

        // when
        underTest.deleteCatalogItem(id);

        // then
        verify(catalogItemRepository).deleteById(id);
    }

    @Test
    void testCanNotDeleteCatalogItem() {
        // given
        UUID id = UUID.randomUUID();
        given(catalogItemRepository.existsById(id)).willReturn(false);

        // when
        // then
        assertThatThrownBy(() -> underTest.deleteCatalogItem(id))
                .isInstanceOf(ApiRequestException.class)
                .hasMessageContaining("Catalog item not found");

        verify(catalogItemRepository, never()).deleteById(any());
    }


    @Test
    void testSearchedTest() {
        // given
        String text = "The city of Azbar was found in first century near the ocean.  " +
                "⌈U-re-me-re⌉, another town , was found " +
                "in 1956.\nThe location of Huga and Duga is not known, but it was probably near Puga.";
        String highlightedText = "The <b>city</b> of <span style='color:green'>Azbar</span> was found in first century near the <b>ocean</b>.  " +
                "⌈<span style='color:green'>U-re-me-re</span>⌉, another town , was found " +
                "in 1956.\nThe location of <span style='color:red'>Huga</span> and <span style='color:red'>Duga</span> is not known, but it was probably near Puga.";

        CatalogItem catalogItem1 = new CatalogItem();
        catalogItem1.setAllNames(Stream.of(new CatalogItemName("Azbar", catalogItem1, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem1.setLatitude(5.0);
        catalogItem1.setLongitude(5.0);

        CatalogItem catalogItem2 = new CatalogItem();
        catalogItem2.setAllNames(Stream.of(new CatalogItemName("Azbar", catalogItem2, 1), new CatalogItemName("Azbarasdf", catalogItem2, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setLatitude(null);
        catalogItem2.setLongitude(null);

        CatalogItem catalogItem3 = new CatalogItem();
        catalogItem3.setAllNames(Stream.of(new CatalogItemName("U-re-me-re", catalogItem3, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem3.setLatitude(55.0);
        catalogItem3.setLongitude(68.0);

        CatalogItem catalogItem4 = new CatalogItem();
        catalogItem4.setAllNames(Stream.of(new CatalogItemName("Huga", catalogItem4, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem4.setLatitude(null);
        catalogItem4.setLongitude(null);

        CatalogItem catalogItem5 = new CatalogItem();
        catalogItem5.setAllNames(Stream.of(new CatalogItemName("Huga", catalogItem5, 1), new CatalogItemName("Hugaa", catalogItem5, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem5.setLatitude(null);
        catalogItem5.setLongitude(null);

        CatalogItem catalogItem6 = new CatalogItem();
        catalogItem6.setAllNames(Stream.of(new CatalogItemName("Duga", catalogItem6, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem6.setLatitude(null);
        catalogItem6.setLongitude(null);

        CatalogItemDto catalogItemDto1 = new CatalogItemDto();
        catalogItemDto1.setId(catalogItem1.getId());
        catalogItemDto1.setAllNames(Stream.of("Azbar").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto1.setLatitude(5.0);
        catalogItemDto1.setLongitude(5.0);

        CatalogItemDto catalogItemDto2 = new CatalogItemDto();
        catalogItemDto2.setId(catalogItem2.getId());
        catalogItemDto2.setAllNames(Stream.of("Azbar", "Azbarasdf").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto2.setLatitude(null);
        catalogItemDto2.setLongitude(null);

        CatalogItemDto catalogItemDto3 = new CatalogItemDto();
        catalogItemDto3.setId(catalogItem3.getId());
        catalogItemDto3.setAllNames(Stream.of("U-re-me-re").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto3.setLatitude(55.0);
        catalogItemDto3.setLongitude(68.0);

        CatalogItemDto catalogItemDto4 = new CatalogItemDto();
        catalogItemDto4.setId(catalogItem4.getId());
        catalogItemDto4.setAllNames(Stream.of("Huga").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto4.setLatitude(null);
        catalogItemDto4.setLongitude(null);

        CatalogItemDto catalogItemDto5 = new CatalogItemDto();
        catalogItemDto5.setId(catalogItem5.getId());
        catalogItemDto5.setAllNames(Stream.of("Huga", "Hugaa").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto5.setLatitude(null);
        catalogItemDto5.setLongitude(null);

        CatalogItemDto catalogItemDto6 = new CatalogItemDto();
        catalogItemDto6.setId(catalogItem6.getId());
        catalogItemDto6.setAllNames(Stream.of("Duga").collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItemDto6.setLatitude(null);
        catalogItemDto6.setLongitude(null);


        given(typeService.getAllTypesAsString()).willReturn(Stream.of("city", "ocean").collect(Collectors.toCollection(LinkedHashSet::new)));
        given(catalogItemRepository.getItemsByName(anyString())).willReturn(Collections.emptyList());
        given(catalogItemRepository.getItemsByName("Azbar")).willReturn(Stream.of(catalogItem1, catalogItem2).collect(Collectors.toList()));
        given(catalogItemRepository.getItemsByName("U-re-me-re")).willReturn(Stream.of(catalogItem3).collect(Collectors.toList()));
        given(catalogItemRepository.getItemsByName("Huga")).willReturn(Stream.of(catalogItem4, catalogItem5).collect(Collectors.toList()));
        given(catalogItemRepository.getItemsByName("Duga")).willReturn(Stream.of(catalogItem6).collect(Collectors.toList()));

        // when
        PathDto pathDto = underTest.getPath(text);

        // then
        verify(catalogItemRepository).getItemsByName("Azbar");
        verify(catalogItemRepository).getItemsByName("U-re-me-re");
        verify(catalogItemRepository).getItemsByName("Huga");
        verify(catalogItemRepository).getItemsByName("Duga");
        verify(catalogItemRepository).getItemsByName("Puga");

        assertThat(pathDto.getText()).isEqualTo(highlightedText);

        assertThat(pathDto.getFoundCatalogItems().size()).isEqualTo(4);

        assertThat(pathDto.getFoundCatalogItems().get(0).size()).isEqualTo(2);
        assertThat(pathDto.getFoundCatalogItems().get(0).get(0)).isEqualTo(catalogItemDto1);
        assertThat(pathDto.getFoundCatalogItems().get(0).get(1)).isEqualTo(catalogItemDto2);

        assertThat(pathDto.getFoundCatalogItems().get(1).size()).isEqualTo(1);
        assertThat(pathDto.getFoundCatalogItems().get(1).get(0)).isEqualTo(catalogItemDto3);

        assertThat(pathDto.getFoundCatalogItems().get(2).size()).isEqualTo(2);
        assertThat(pathDto.getFoundCatalogItems().get(2).get(0)).isEqualTo(catalogItemDto4);
        assertThat(pathDto.getFoundCatalogItems().get(2).get(1)).isEqualTo(catalogItemDto5);

        assertThat(pathDto.getFoundCatalogItems().get(3).size()).isEqualTo(1);
        assertThat(pathDto.getFoundCatalogItems().get(3).get(0)).isEqualTo(catalogItemDto6);
    }
}