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

package cz.zcu.kiv.backendapi.catalog;

import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
import cz.zcu.kiv.backendapi.alternativename.AlternativeNameRepository;
import cz.zcu.kiv.backendapi.bibliography.Bibliography;
import cz.zcu.kiv.backendapi.bibliography.BibliographyRepository;
import cz.zcu.kiv.backendapi.country.Country;
import cz.zcu.kiv.backendapi.country.CountryRepository;
import cz.zcu.kiv.backendapi.type.Type;
import cz.zcu.kiv.backendapi.type.TypeRepository;
import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
import cz.zcu.kiv.backendapi.writtenform.WrittenFormRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;

@DataJpaTest
class CatalogItemRepositoryTest {

    @Autowired
    private CatalogItemRepository underTest;

    @Autowired
    private TypeRepository typeRepository;

    @Autowired
    private CountryRepository countryRepository;

    @Autowired
    private WrittenFormRepository writtenFormRepository;

    @Autowired
    private AlternativeNameRepository alternativeNameRepository;

    @Autowired
    private BibliographyRepository bibliographyRepository;

    private CatalogItem catalogItem1;
    private CatalogItem catalogItem2;
    private CatalogItem catalogItem3;
    private CatalogItem catalogItem4;
    private CatalogItem catalogItem5;

    @BeforeEach
    void setUp() {
        Type typeCountry = new Type("country");
        Type typeCity = new Type("city");
        Type typeCapitalCity = new Type("capital city new");
        Type typeCityUpper = new Type("City");
        Type typeCountri = new Type("countri");
        typeRepository.saveAll(List.of(typeCountry, typeCity, typeCapitalCity, typeCityUpper, typeCountri));

        String nameFirst = "first";
        String nameFirstUpper = "First";
        String nameSecond = "second";
        String nameSedond = "sedond";
        String nameThird = "third";
        String nameTwelve = "twelve";
        String nameTwentyUpper = "TWENTY";

        String countryAaa = "aaa";
        String countryAaaUpper = "AAA";
        String countryBbb = "bbb";
        String countryBccb = "bccb";
        String countryCcc = "ccc";
        String countryDdd = "ddd";
        String countryDcd = "dcd";

        catalogItem1 = new CatalogItem();
        catalogItem2 = new CatalogItem();
        catalogItem3 = new CatalogItem();
        catalogItem4 = new CatalogItem();
        catalogItem5 = new CatalogItem();

        catalogItem1.setName(nameFirst);
        catalogItem1.setTypes(Stream.of(typeCountry, typeCity).collect(Collectors.toSet()));
        catalogItem1.setCountries(Stream.of(new Country(countryAaa, catalogItem1), new Country(countryDcd, catalogItem1)).collect(Collectors.toSet()));

        catalogItem2.setName(nameSecond);
        catalogItem2.setAlternativeNames(Stream.of(new AlternativeName(nameTwelve, catalogItem2), new AlternativeName(nameThird, catalogItem2)).collect(Collectors.toSet()));
        catalogItem2.setTypes(Stream.of(typeCountry, typeCityUpper).collect(Collectors.toSet()));
        catalogItem2.setCountries(Stream.of(new Country(countryAaa, catalogItem2), new Country(countryBbb, catalogItem2)).collect(Collectors.toSet()));
        catalogItem2.setBibliography(Stream.of(new Bibliography("bibl", catalogItem2)).collect(Collectors.toSet()));
        catalogItem2.setWrittenForms(Stream.of(new WrittenForm("wr", catalogItem2), new WrittenForm("wr2", catalogItem2)).collect(Collectors.toSet()));

        catalogItem3.setName(nameThird);
        catalogItem3.setAlternativeNames(Stream.of(new AlternativeName(nameTwentyUpper, catalogItem3), new AlternativeName(nameSedond, catalogItem3)).collect(Collectors.toSet()));
        catalogItem3.setTypes(Stream.of(typeCountri, typeCapitalCity).collect(Collectors.toSet()));
        catalogItem3.setCountries(Stream.of(new Country(countryAaaUpper, catalogItem3), new Country(countryCcc, catalogItem3)).collect(Collectors.toSet()));


        catalogItem4.setAlternativeNames(Stream.of(new AlternativeName(nameTwelve, catalogItem4), new AlternativeName(nameFirstUpper, catalogItem4)).collect(Collectors.toSet()));
        catalogItem4.setTypes(Stream.of(typeCountri, typeCountry).collect(Collectors.toSet()));
        catalogItem4.setCountries(Stream.of(new Country(countryBccb, catalogItem4), new Country(countryDdd, catalogItem4)).collect(Collectors.toSet()));


        catalogItem5.setName(nameSedond);
        catalogItem5.setAlternativeNames(Stream.of(new AlternativeName(nameThird, catalogItem5)).collect(Collectors.toSet()));
        catalogItem5.setTypes(Stream.of(typeCountri).collect(Collectors.toSet()));

        underTest.saveAll(List.of(catalogItem1, catalogItem2, catalogItem3, catalogItem4, catalogItem5));


    }

    @AfterEach
    void tearDown() {
        underTest.deleteAll();
    }

    @Test
    void itShouldReturnAll() {
        // given
        String name = "";
        String country = "";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(5);
    }

    @Test
    void testName() {
        // given
        String name = "first";
        String country = "";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem4));
    }

    @Test
    void testWildcardCharacterName() {
        // given
        String name = "se_ond";
        String country = "";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
        assertTrue(filterResult.contains(catalogItem5));
    }

    @Test
    void testWildcardCharactersName() {
        // given
        String name = "twe%";
        String country = "";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
        assertTrue(filterResult.contains(catalogItem4));
    }

    @Test
    void testCountry() {
        // given
        String name = "";
        String country = "aaa";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
    }

    @Test
    void testWildcardCharacterCountry() {
        // given
        String name = "";
        String country = "d_d";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem4));
    }

    @Test
    void testWildcardCharactersCountry() {
        // given
        String name = "";
        String country = "b%b";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem4));
    }


    @Test
    void testType() {
        // given
        String name = "";
        String country = "";
        String type = "city";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem2));
    }

    @Test
    void testWildcardCharacterType() {
        // given
        String name = "";
        String country = "";
        String type = "countr_";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(5);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
        assertTrue(filterResult.contains(catalogItem4));
        assertTrue(filterResult.contains(catalogItem5));
    }

    @Test
    void testWildcardCharactersType() {
        // given
        String name = "";
        String country = "";
        String type = "%city%";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItem1));
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
    }

    @Test
    void testNameAndCountry() {
        // given
        String name = "third";
        String country = "aaa";
        String type = "";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem2));
        assertTrue(filterResult.contains(catalogItem3));
    }

    @Test
    void testNameAndType() {
        // given
        String name = "third";
        String country = "";
        String type = "countri";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItem3));
        assertTrue(filterResult.contains(catalogItem5));
    }

    @Test
    void testCountryAndType() {
        // given
        String name = "";
        String country = "ddd";
        String type = "country";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(1);
        assertTrue(filterResult.contains(catalogItem4));
    }

    @Test
    void testAll() {
        // given
        String name = "third";
        String country = "AAA";
        String type = "countri";

        // when
        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);

        // then
        assertThat(filterResult.size()).isEqualTo(1);
        assertTrue(filterResult.contains(catalogItem3));
    }

    @Test
    void testUpdate() {
        // given
        int originalCountriesCount = countryRepository.findAll().size();
        int originalNamesCount = alternativeNameRepository.findAll().size();
        int originalWrittenFormsCount = writtenFormRepository.findAll().size();
        int originalTypesCount = typeRepository.findAll().size();
        int originalBibliographyCount = bibliographyRepository.findAll().size();

        // when
        catalogItem2.getCountries().clear();
        catalogItem2.getCountries().addAll(Stream.of(new Country("aaa", catalogItem2)).collect(Collectors.toSet()));

        catalogItem2.getAlternativeNames().clear();
        catalogItem2.getAlternativeNames().addAll(Stream.of(new AlternativeName("aaa", catalogItem2)).collect(Collectors.toSet()));

        catalogItem2.getWrittenForms().clear();
        catalogItem2.getWrittenForms().addAll(Stream.of(new WrittenForm("aaa", catalogItem2), new WrittenForm("aaaa", catalogItem2), new WrittenForm("aaaaa", catalogItem2)).collect(Collectors.toSet()));

        catalogItem2.getBibliography().clear();
        catalogItem2.getBibliography().addAll(Stream.of(new Bibliography("aaa", catalogItem2), new Bibliography("aaaa", catalogItem2)).collect(Collectors.toSet()));

        catalogItem2.getTypes().clear();
        catalogItem2.getTypes().addAll(Stream.of(new Type("country")).collect(Collectors.toSet()));

        underTest.save(catalogItem2);

        // then
        assertThat(typeRepository.findAll().size()).isEqualTo(originalTypesCount);
        assertThat(countryRepository.findAll().size()).isEqualTo(originalCountriesCount - 1);
        assertThat(alternativeNameRepository.findAll().size()).isEqualTo(originalNamesCount - 1);
        assertThat(bibliographyRepository.findAll().size()).isEqualTo(originalBibliographyCount + 1);
        assertThat(writtenFormRepository.findAll().size()).isEqualTo(originalWrittenFormsCount + 1);

    }

    @Test
    void testDelete() {
        // given
        int expectedCountriesCount = countryRepository.findAll().size() - catalogItem2.getCountries().size();
        int expectedNamesCount = alternativeNameRepository.findAll().size() - catalogItem2.getAlternativeNames().size();
        int expectedWrittenFormsCount = writtenFormRepository.findAll().size() - catalogItem2.getWrittenForms().size();
        int expectedTypesCount = typeRepository.findAll().size();
        int expectedBibliographyCount = bibliographyRepository.findAll().size() - catalogItem2.getBibliography().size();

        // when
        underTest.delete(catalogItem2);

        // then
        assertThat(typeRepository.findAll().size()).isEqualTo(expectedTypesCount);
        assertThat(countryRepository.findAll().size()).isEqualTo(expectedCountriesCount);
        assertThat(alternativeNameRepository.findAll().size()).isEqualTo(expectedNamesCount);
        assertThat(bibliographyRepository.findAll().size()).isEqualTo(expectedBibliographyCount);
        assertThat(writtenFormRepository.findAll().size()).isEqualTo(expectedWrittenFormsCount);

    }
}