Revize abaa5f46

Experiment with database

backend/src/test/java/cz/zcu/kiv/backendapi/catalog/CatalogItemRepositoryTest.java

@@ -1 +1 @@
 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;
@@ -11 +17 @@
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
 
 import java.util.List;
-import java.util.Set;
+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.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @DataJpaTest
 class CatalogItemRepositoryTest {
@@ -25 +32 @@
     @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;
@@ -63 +82 @@
         catalogItem5 = new CatalogItem();
 
         catalogItem1.setName(nameFirst);
-        catalogItem1.setTypes(Set.of(typeCountry, typeCity));
-        catalogItem1.setCountries(Set.of(new Country(countryAaa, catalogItem1), new Country(countryDcd, catalogItem1)));
+        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(Set.of(new AlternativeName(nameTwelve, catalogItem2), new AlternativeName(nameThird, catalogItem2)));
-        catalogItem2.setTypes(Set.of(typeCountry, typeCityUpper));
-        catalogItem2.setCountries(Set.of(new Country(countryAaa, catalogItem2), new Country(countryBbb, catalogItem2)));
+        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(Set.of(new AlternativeName(nameTwentyUpper, catalogItem3), new AlternativeName(nameSedond, catalogItem3)));
-        catalogItem3.setTypes(Set.of(typeCountri, typeCapitalCity));
-        catalogItem3.setCountries(Set.of(new Country(countryAaaUpper, catalogItem3), new Country(countryCcc, catalogItem3)));
+        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(Set.of(new AlternativeName(nameTwelve, catalogItem4), new AlternativeName(nameFirstUpper, catalogItem4)));
-        catalogItem4.setTypes(Set.of(typeCountri, typeCountry));
-        catalogItem4.setCountries(Set.of(new Country(countryBccb, catalogItem4), new Country(countryDdd, catalogItem4)));
+        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(Set.of(new AlternativeName(nameThird, catalogItem5)));
-        catalogItem5.setTypes(Set.of(typeCountri));
+        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));
 
@@ -104 +125 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(5);
@@ -118 +139 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -134 +155 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -151 +172 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -168 +189 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -185 +206 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -201 +222 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -218 +239 @@
         String type = "city";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -234 +255 @@
         String type = "countr_";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(5);
@@ -253 +274 @@
         String type = "%city%";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(3);
@@ -270 +291 @@
         String type = "";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -286 +307 @@
         String type = "countri";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(2);
@@ -302 +323 @@
         String type = "country";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        List<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
 
         // then
         assertThat(filterResult.size()).isEqualTo(1);
@@ -317 +338 @@
         String type = "countri";
 
         // when
-        Set<CatalogItem> filterResult = underTest.filterCatalog(name, country, type);
+        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);
+
+    }
 }