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

package cz.zcu.kiv.backendapi.catalog;

import cz.zcu.kiv.backendapi.alternativename.CatalogItemName;
import cz.zcu.kiv.backendapi.country.Country;
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.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.UUID;
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;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.verify;

@ExtendWith(MockitoExtension.class)
class CatalogItemServiceImplFilterTest {
    @Mock
    private CatalogItemRepository catalogItemRepository;

    @Mock
    private TypeServiceImpl typeService;

    private CatalogItemServiceImpl underTest;

    private CatalogItemDto catalogItemDto1;
    private CatalogItemDto catalogItemDto2;
    private CatalogItemDto catalogItemDto3;
    private CatalogItemDto catalogItemDto4;
    private CatalogItemDto catalogItemDto5;

    @BeforeEach
    void setUp() {
        underTest = new CatalogItemServiceImpl(catalogItemRepository, typeService);
        // given
        String country = "country";
        String city = "city";
        String capitalCityNew = "capital city new";
        String cityUpper = "City";
        String countri = "countri";

        Type typeCountry = new Type(country);
        Type typeCity = new Type(city);
        Type typeCapitalCity = new Type(capitalCityNew);
        Type typeCityUpper = new Type(cityUpper);
        Type typeCountri = new Type(countri);

        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";

        String writtenForm = "written";
        String writtenFormUpper = "WRITTEN";
        String writtenFormForOr = "wratten";

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

        UUID catalogItemId1 = UUID.randomUUID();
        UUID catalogItemId2 = UUID.randomUUID();
        UUID catalogItemId3 = UUID.randomUUID();
        UUID catalogItemId4 = UUID.randomUUID();
        UUID catalogItemId5 = UUID.randomUUID();

        catalogItem1.setId(catalogItemId1);
        catalogItem2.setId(catalogItemId2);
        catalogItem3.setId(catalogItemId3);
        catalogItem4.setId(catalogItemId4);
        catalogItem5.setId(catalogItemId5);

        catalogItem1.setName(nameFirst);
        catalogItem1.setTypes(Stream.of(typeCountry, typeCity).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem1.setCountries(Stream.of(new Country(countryAaa, catalogItem1, 1), new Country(countryDcd, catalogItem1, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem1.setWrittenForms(Stream.of(new WrittenForm(writtenForm, catalogItem1, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItemDto1 = new CatalogItemDto(catalogItemId1, nameFirst, new LinkedHashSet<>(), Stream.of(writtenForm).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(country, city).collect(Collectors.toCollection(LinkedHashSet::new)), Stream.of(countryAaa, countryDcd).collect(Collectors.toCollection(LinkedHashSet::new)),
                new LinkedHashSet<>(), null, null, null, "");

        catalogItem2.setName(nameSecond);
        catalogItem2.setAllNames(Stream.of(new CatalogItemName(nameTwelve, catalogItem2, 1), new CatalogItemName(nameThird, catalogItem2, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setTypes(Stream.of(typeCountry, typeCityUpper).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setCountries(Stream.of(new Country(countryAaa, catalogItem2, 1), new Country(countryBbb, catalogItem2, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem2.setWrittenForms(Stream.of(new WrittenForm(writtenFormUpper, catalogItem2, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItemDto2 = new CatalogItemDto(catalogItemId2, nameSecond, Stream.of(nameTwelve, nameThird).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(writtenFormUpper).collect(Collectors.toCollection(LinkedHashSet::new)), Stream.of(country, cityUpper).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(countryAaa, countryBbb).collect(Collectors.toCollection(LinkedHashSet::new)), new LinkedHashSet<>(),
                null, null, null, "");

        catalogItem3.setName(nameThird);
        catalogItem3.setAllNames(Stream.of(new CatalogItemName(nameTwentyUpper, catalogItem3, 1), new CatalogItemName(nameSedond, catalogItem3, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem3.setTypes(Stream.of(typeCountri, typeCapitalCity).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem3.setCountries(Stream.of(new Country(countryAaaUpper, catalogItem3, 1), new Country(countryCcc, catalogItem3, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem3.setWrittenForms(Stream.of(new WrittenForm(writtenFormForOr, catalogItem3, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItemDto3 = new CatalogItemDto(catalogItemId3, nameThird, Stream.of(nameTwentyUpper, nameSedond).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(writtenFormForOr).collect(Collectors.toCollection(LinkedHashSet::new)), Stream.of(countri, capitalCityNew).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(countryAaaUpper, countryCcc).collect(Collectors.toCollection(LinkedHashSet::new)), new LinkedHashSet<>(),
                null, null, null, "");

        catalogItem4.setAllNames(Stream.of(new CatalogItemName(nameTwelve, catalogItem4, 1), new CatalogItemName(nameFirstUpper, catalogItem4, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem4.setTypes(Stream.of(typeCountri, typeCountry).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem4.setCountries(Stream.of(new Country(countryBccb, catalogItem4, 1), new Country(countryDdd, catalogItem4, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem4.setWrittenForms(Stream.of(new WrittenForm(writtenForm, catalogItem4, 1), new WrittenForm(writtenFormForOr, catalogItem4, 2)).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItemDto4 = new CatalogItemDto(catalogItemId4, "", Stream.of(nameTwelve, nameFirstUpper).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(writtenForm, writtenFormForOr).collect(Collectors.toCollection(LinkedHashSet::new)), Stream.of(countri, country).collect(Collectors.toCollection(LinkedHashSet::new)),
                Stream.of(countryBccb, countryDdd).collect(Collectors.toCollection(LinkedHashSet::new)), new LinkedHashSet<>(),
                null, null, null, "");

        catalogItem5.setName(nameSedond);
        catalogItem5.setAllNames(Stream.of(new CatalogItemName(nameThird, catalogItem5, 1)).collect(Collectors.toCollection(LinkedHashSet::new)));
        catalogItem5.setTypes(Stream.of(typeCountri).collect(Collectors.toCollection(LinkedHashSet::new)));

        catalogItemDto5 = new CatalogItemDto(catalogItemId5, nameSedond, Stream.of(nameThird).collect(Collectors.toCollection(LinkedHashSet::new)),
                new LinkedHashSet<>(), Stream.of(countri).collect(Collectors.toCollection(LinkedHashSet::new)),
                new LinkedHashSet<>(), new LinkedHashSet<>(),
                null, null, null, "");

        given(catalogItemRepository.findAll()).willReturn(List.of(catalogItem1, catalogItem2, catalogItem3, catalogItem4, catalogItem5));
    }

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

        // when
        List<CatalogItemDto> results = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(results.size()).isEqualTo(5);
        assertTrue(results.contains(catalogItemDto1));
        assertTrue(results.contains(catalogItemDto2));
        assertTrue(results.contains(catalogItemDto3));
        assertTrue(results.contains(catalogItemDto4));
        assertTrue(results.contains(catalogItemDto5));

        verify(catalogItemRepository).findAll();
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

    @Test
    void testWildcardCharacterName() {
        // given
        String name = "se?ond";
        String country = "";
        String type = "";
        String writtenForm = "";

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto5));
    }

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


        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

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


        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto4));
    }


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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(5);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto4));
        assertTrue(filterResult.contains(catalogItemDto5));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
    }

    @Test
    void testWrittenForm() {
        // given
        String name = "";
        String country = "";
        String type = "";
        String writtenForm = "written";

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

    @Test
    void testWrittenFormWildcardCharacter() {
        // given
        String name = "";
        String country = "";
        String type = "";
        String writtenForm = "wr?tten";

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(4);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

    @Test
    void testWrittenFormWildcardCharacters() {
        // given
        String name = "";
        String country = "";
        String type = "";
        String writtenForm = "wri*tten";

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(3);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

    @Test
    void testWrittenFormOr() {
        // given
        String name = "";
        String country = "";
        String type = "";
        String writtenForm = "wr(i|a)tten";

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(4);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto2));
        assertTrue(filterResult.contains(catalogItemDto3));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto3));
        assertTrue(filterResult.contains(catalogItemDto5));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

        // then
        assertThat(filterResult.size()).isEqualTo(2);
        assertTrue(filterResult.contains(catalogItemDto1));
        assertTrue(filterResult.contains(catalogItemDto4));
    }

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

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

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

        // when
        List<CatalogItemDto> filterResult = underTest.getCatalog(name, country, type, writtenForm);

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