Revize 15f5a407

Added first unit tests
- for catalog and user repository
- for type and title page service
re #9363

backend/pom.xml

@@ -33 +33 @@
             <scope>test</scope>
         </dependency>
 
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
 
         <dependency>
             <groupId>org.postgresql</groupId>
@@ -82 +87 @@
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-configuration-processor</artifactId>
-            <version>2.4.2</version>
+            <version>2.6.5</version>
             <optional>true</optional>
         </dependency>
 

backend/src/main/java/cz/zcu/kiv/backendapi/alternativename/AlternativeName.java

@@ -3 +3 @@
 import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
 import javax.persistence.*;
@@ -12 +13 @@
  * Alternative name entity representing alternative name of geographic entry
  */
 @Data
+@EqualsAndHashCode(exclude = "catalog")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity

backend/src/main/java/cz/zcu/kiv/backendapi/bibliography/Bibliography.java

@@ -3 +3 @@
 import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
 import javax.persistence.*;
@@ -12 +13 @@
  * Bibliography entity representing bibliography
  */
 @Data
+@EqualsAndHashCode(exclude = "catalog")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogEntry.java

@@ -5 +5 @@
 import cz.zcu.kiv.backendapi.country.Country;
 import cz.zcu.kiv.backendapi.type.Type;
 import cz.zcu.kiv.backendapi.writtenform.WrittenForm;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
+import lombok.*;
 import org.hibernate.annotations.LazyCollection;
 import org.hibernate.annotations.LazyCollectionOption;
 
@@ -20 +18 @@
 /**
  * Catalog entity representing catalog entry
  */
-//@Data
-@Getter
-@Setter
+@Data
 @NoArgsConstructor
 @Entity
 @Table(name = "catalog")
@@ -104 +100 @@
 
         this.name = csvFields.get(1);
         List<String> stringList = processListField(csvFields.get(2));
-        this.alternativeNames = stringList.stream().map(s->new AlternativeName(s, this)).collect(Collectors.toSet());
+        this.alternativeNames = stringList.stream().map(s -> new AlternativeName(s, this)).collect(Collectors.toSet());
 
         this.certainty = processIntField(csvFields.get(3));
         this.latitude = processDoubleField(csvFields.get(4));
         this.longitude = processDoubleField(csvFields.get(5));
 
         stringList = processListField(csvFields.get(6));
-        this.writtenForms = stringList.stream().map(s->new WrittenForm(s, this)).collect(Collectors.toSet());
+        this.writtenForms = stringList.stream().map(s -> new WrittenForm(s, this)).collect(Collectors.toSet());
 
         stringList = processListField(csvFields.get(7));
         this.types = stringList.stream().map(Type::new).collect(Collectors.toSet());
 
         stringList = processListField(csvFields.get(8));
-        this.countries = stringList.stream().map(s->new Country(s, this)).collect(Collectors.toSet());
+        this.countries = stringList.stream().map(s -> new Country(s, this)).collect(Collectors.toSet());
 
         stringList = processListField(csvFields.get(9));
-        this.bibliography = stringList.stream().map(s->new Bibliography(s, this)).collect(Collectors.toSet());
+        this.bibliography = stringList.stream().map(s -> new Bibliography(s, this)).collect(Collectors.toSet());
     }
 
     private int processIntField(String field) {

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogEntryRepository.java

@@ -24 +24 @@
     @Query("SELECT DISTINCT e FROM CatalogEntry e LEFT JOIN AlternativeName a ON e = a.catalog " +
             "LEFT JOIN Country c ON e = c.catalog " +
             "INNER JOIN e.types t " +
-            "WHERE (?1 = '' OR e.name LIKE ?1 OR a.name LIKE ?1) " +
-            "AND (?2 = '' OR c.name LIKE ?2) " +
-            "AND (?3 = '' OR t.type LIKE ?3)")
+            "WHERE (?1 = '' OR UPPER(e.name) LIKE UPPER(?1) OR UPPER(a.name) LIKE UPPER(?1)) " +
+            "AND (?2 = '' OR UPPER(c.name) LIKE UPPER(?2)) " +
+            "AND (?3 = '' OR UPPER(t.type) LIKE UPPER(?3))")
     Set<CatalogEntry> filterCatalog(String name, String country, String type);
 }

backend/src/main/java/cz/zcu/kiv/backendapi/catalog/CatalogEntryServiceImpl.java

@@ -26 +26 @@
 @RequiredArgsConstructor
 @Slf4j
 public class CatalogEntryServiceImpl implements ICatalogEntryService {
+    /**
+     * Regex for one arbitrary character in string
+     */
+    private static final String WILDCARD_CHARACTER_REGEX = "\\?";
+
+    /**
+     * Regex for one arbitrary character in string used in SQL language
+     */
+    private static final String WILDCARD_CHARACTER_REGEX_SQL = "_";
+
+    /**
+     * Regex for any number of arbitrary characters in string
+     */
+    private static final String WILDCARD_CHARACTERS_REGEX = "\\*";
+
+    /**
+     * Regex for any number of arbitrary characters in string used in SQL language
+     */
+    private static final String WILDCARD_CHARACTERS_REGEX_SQL = "%";
+
     /**
      * Message for exception when catalog entry is not found by id
      */
     private static final String CATALOG_ENTRY_NOT_FOUND = "Catalog entry not found";
+
     /**
      * Catalog repository
      */
@@ -78 +99 @@
     @Override
     public List<CatalogEntryDto> getCatalog(String name, String country, String type) {
         log.info("Retrieving catalog");
+        name = name.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
+        name = name.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
+        country = country.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
+        country = country.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
+        type = type.replaceAll(WILDCARD_CHARACTER_REGEX, WILDCARD_CHARACTER_REGEX_SQL);
+        type = type.replaceAll(WILDCARD_CHARACTERS_REGEX, WILDCARD_CHARACTERS_REGEX_SQL);
         Set<CatalogEntry> entities = catalogEntryRepository.filterCatalog(name, country, type);
         return entities.stream().map(this::convertEntityToDto).collect(Collectors.toList());
     }

backend/src/main/java/cz/zcu/kiv/backendapi/config/DataInitiator.java

@@ -43 +43 @@
     @Transactional
     public void onApplicationEvent(ContextRefreshedEvent event) {
         List<Type> types = loadTypes();
-        typeService.saveTypes(types);
+        for (Type type : types) {
+            typeService.saveType(type);
+        }
         List<CatalogEntry> catalog = loadCatalog();
         catalogService.saveCatalog(catalog);
 

backend/src/main/java/cz/zcu/kiv/backendapi/country/Country.java

@@ -3 +3 @@
 import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
 import javax.persistence.*;
@@ -12 +13 @@
  * Country entity representing country of geographic entry
  */
 @Data
+@EqualsAndHashCode(exclude = "catalog")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity

backend/src/main/java/cz/zcu/kiv/backendapi/password/PasswordDto.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.password;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import cz.zcu.kiv.backendapi.validation.PasswordMatches;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import javax.validation.constraints.NotEmpty;
-import javax.validation.constraints.NotNull;
-import javax.validation.constraints.Size;
-
-/**
- * Password data object
- */
-@Data
-@PasswordMatches
-@NoArgsConstructor
-public class PasswordDto {
-    /**
-     * Minimal length for password
-     */
-    @JsonIgnore
-    private  static final int MIN_PASSWORD_LENGTH = 8;
-
-    /**
-     * New password - must be strong enough
-     */
-    @NotNull(message = "Password must not be null")
-    @NotEmpty(message = "Password must not be empty")
-    @Size(min = MIN_PASSWORD_LENGTH, message = "Password must be at least " + MIN_PASSWORD_LENGTH + " characters long")
-    private String password;
-
-    /**
-     * New password confirmation - must match new password
-     */
-    @NotNull(message = "Confirmation password must not be null")
-    @NotEmpty(message = "Confirmation password must not be empty")
-    private String confirmationPassword;
-
-}

backend/src/main/java/cz/zcu/kiv/backendapi/permission/PermissionDto.java

@@ -1 @@
-package cz.zcu.kiv.backendapi.permission;
-
-import lombok.Data;
-
-/**
- * Permission DTO
- */
-@Data
-public class PermissionDto {
-    /**
-     * Whether user has 'READ' authority
-     */
-    private boolean canRead;
-
-    /**
-     * Whether user has 'WRITE' authority
-     */
-    private boolean canWrite;
-
-    /**
-     * Whether user has 'DELETE' authority
-     */
-    private boolean canDelete;
-}

backend/src/main/java/cz/zcu/kiv/backendapi/security/jwt/JwtUtils.java

@@ -68 +68 @@
      */
     @Bean
     public Algorithm getAlgorithm() {
-        return Algorithm.HMAC256(secretKey.getBytes());
+        return Algorithm.HMAC512(secretKey.getBytes());
     }
 
     /**

backend/src/main/java/cz/zcu/kiv/backendapi/type/ITypeService.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.type;
 
-import java.util.List;
 import java.util.Optional;
 
 /**
@@ -8 +7 @@
  */
 public interface ITypeService {
 
+    /**
+     * Saves on type
+     *
+     * @param type type
+     */
     void saveType(Type type);
 
-    void saveTypes(List<Type> typesEntities);
-
+    /**
+     * Returns type by name (optional)
+     *
+     * @param type type name
+     * @return type by name (optional)
+     */
     Optional<Type> getTypeByName(String type);
 }

backend/src/main/java/cz/zcu/kiv/backendapi/type/TypeServiceImpl.java

@@ -4 +4 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
 import java.util.Optional;
 
 /**
@@ -24 +23 @@
         typeRepository.save(type);
     }
 
-    @Override
-    public void saveTypes(List<Type> typesEntities) {
-        typeRepository.saveAll(typesEntities);
-    }
-
     @Override
     public Optional<Type> getTypeByName(String type) {
         return typeRepository.findById(type);

backend/src/main/java/cz/zcu/kiv/backendapi/user/IUserService.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.user;
 
-import cz.zcu.kiv.backendapi.password.PasswordDto;
-import cz.zcu.kiv.backendapi.permission.PermissionDto;
+import cz.zcu.kiv.backendapi.user.password.PasswordDto;
+import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
 
 import java.util.List;
 

backend/src/main/java/cz/zcu/kiv/backendapi/user/UserController.java

@@ -6 +6 @@
 import com.auth0.jwt.interfaces.DecodedJWT;
 import com.google.common.base.Strings;
 import cz.zcu.kiv.backendapi.exception.ApiRequestException;
-import cz.zcu.kiv.backendapi.password.PasswordDto;
+import cz.zcu.kiv.backendapi.user.password.PasswordDto;
 import cz.zcu.kiv.backendapi.security.jwt.JwtUtils;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -15 +15 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.GrantedAuthority;
 import org.springframework.web.bind.annotation.*;
-import cz.zcu.kiv.backendapi.permission.PermissionDto;
+import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

backend/src/main/java/cz/zcu/kiv/backendapi/user/UserDto.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.user;
 
-import cz.zcu.kiv.backendapi.password.PasswordDto;
+import cz.zcu.kiv.backendapi.user.password.PasswordDto;
 import cz.zcu.kiv.backendapi.validation.PasswordMatches;
 import cz.zcu.kiv.backendapi.validation.ValidEmail;
 import lombok.Data;
-import cz.zcu.kiv.backendapi.permission.PermissionDto;
+import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotEmpty;

backend/src/main/java/cz/zcu/kiv/backendapi/user/UserEntity.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.user;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import org.hibernate.annotations.Type;

backend/src/main/java/cz/zcu/kiv/backendapi/user/UserServiceImpl.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.user;
 
 import cz.zcu.kiv.backendapi.exception.ApiRequestException;
-import cz.zcu.kiv.backendapi.password.PasswordDto;
+import cz.zcu.kiv.backendapi.user.password.PasswordDto;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.HttpStatus;
@@ -12 +12 @@
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import cz.zcu.kiv.backendapi.permission.PermissionDto;
+import cz.zcu.kiv.backendapi.user.permission.PermissionDto;
 
 import java.util.List;
 import java.util.stream.Collectors;

backend/src/main/java/cz/zcu/kiv/backendapi/user/password/PasswordDto.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.user.password;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import cz.zcu.kiv.backendapi.validation.PasswordMatches;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+
+/**
+ * Password data object
+ */
+@Data
+@PasswordMatches
+@NoArgsConstructor
+public class PasswordDto {
+    /**
+     * Minimal length for password
+     */
+    @JsonIgnore
+    private  static final int MIN_PASSWORD_LENGTH = 8;
+
+    /**
+     * New password - must be strong enough
+     */
+    @NotNull(message = "Password must not be null")
+    @NotEmpty(message = "Password must not be empty")
+    @Size(min = MIN_PASSWORD_LENGTH, message = "Password must be at least " + MIN_PASSWORD_LENGTH + " characters long")
+    private String password;
+
+    /**
+     * New password confirmation - must match new password
+     */
+    @NotNull(message = "Confirmation password must not be null")
+    @NotEmpty(message = "Confirmation password must not be empty")
+    private String confirmationPassword;
+
+}

backend/src/main/java/cz/zcu/kiv/backendapi/user/permission/PermissionDto.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.user.permission;
+
+import lombok.Data;
+
+/**
+ * Permission DTO
+ */
+@Data
+public class PermissionDto {
+    /**
+     * Whether user has 'READ' authority
+     */
+    private boolean canRead;
+
+    /**
+     * Whether user has 'WRITE' authority
+     */
+    private boolean canWrite;
+
+    /**
+     * Whether user has 'DELETE' authority
+     */
+    private boolean canDelete;
+}

backend/src/main/java/cz/zcu/kiv/backendapi/validation/PasswordMatchesValidator.java

@@ -1 +1 @@
 package cz.zcu.kiv.backendapi.validation;
 
-import cz.zcu.kiv.backendapi.password.PasswordDto;
+import cz.zcu.kiv.backendapi.user.password.PasswordDto;
 
 import javax.validation.ConstraintValidator;
 import javax.validation.ConstraintValidatorContext;

backend/src/main/java/cz/zcu/kiv/backendapi/writtenform/WrittenForm.java

@@ -3 +3 @@
 import cz.zcu.kiv.backendapi.catalog.CatalogEntry;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
 import javax.persistence.*;
@@ -12 +13 @@
  * Written form entity representing written form of geographic entry
  */
 @Data
+@EqualsAndHashCode(exclude = "catalog")
 @NoArgsConstructor
 @AllArgsConstructor
 @Entity

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

@@ +1 @@
+package cz.zcu.kiv.backendapi.catalog;
+
+import cz.zcu.kiv.backendapi.alternativename.AlternativeName;
+import cz.zcu.kiv.backendapi.country.Country;
+import cz.zcu.kiv.backendapi.type.Type;
+import cz.zcu.kiv.backendapi.type.TypeRepository;
+import cz.zcu.kiv.backendapi.user.UserEntity;
+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.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+@DataJpaTest
+class CatalogEntryRepositoryTest {
+
+    @Autowired
+    private CatalogEntryRepository underTest;
+
+    @Autowired
+    private TypeRepository typeRepository;
+
+    private CatalogEntry catalogEntry1;
+    private CatalogEntry catalogEntry2;
+    private CatalogEntry catalogEntry3;
+    private CatalogEntry catalogEntry4;
+    private CatalogEntry catalogEntry5;
+
+    @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";
+
+        catalogEntry1 = new CatalogEntry();
+        catalogEntry2 = new CatalogEntry();
+        catalogEntry3 = new CatalogEntry();
+        catalogEntry4 = new CatalogEntry();
+        catalogEntry5 = new CatalogEntry();
+
+        catalogEntry1.setName(nameFirst);
+        catalogEntry1.setTypes(Set.of(typeCountry, typeCity));
+        catalogEntry1.setCountries(Set.of(new Country(countryAaa, catalogEntry1), new Country(countryDcd, catalogEntry1)));
+
+        catalogEntry2.setName(nameSecond);
+        catalogEntry2.setAlternativeNames(Set.of(new AlternativeName(nameTwelve, catalogEntry2), new AlternativeName(nameThird, catalogEntry2)));
+        catalogEntry2.setTypes(Set.of(typeCountry, typeCityUpper));
+        catalogEntry2.setCountries(Set.of(new Country(countryAaa, catalogEntry2), new Country(countryBbb, catalogEntry2)));
+
+        catalogEntry3.setName(nameThird);
+        catalogEntry3.setAlternativeNames(Set.of(new AlternativeName(nameTwentyUpper, catalogEntry3), new AlternativeName(nameSedond, catalogEntry3)));
+        catalogEntry3.setTypes(Set.of(typeCountri, typeCapitalCity));
+        catalogEntry3.setCountries(Set.of(new Country(countryAaaUpper, catalogEntry3), new Country(countryCcc, catalogEntry3)));
+
+
+        catalogEntry4.setAlternativeNames(Set.of(new AlternativeName(nameTwelve, catalogEntry4), new AlternativeName(nameFirstUpper, catalogEntry4)));
+        catalogEntry4.setTypes(Set.of(typeCountri, typeCountry));
+        catalogEntry4.setCountries(Set.of(new Country(countryBccb, catalogEntry4), new Country(countryDdd, catalogEntry4)));
+
+
+        catalogEntry5.setName(nameSedond);
+        catalogEntry5.setAlternativeNames(Set.of(new AlternativeName(nameThird, catalogEntry5)));
+        catalogEntry5.setTypes(Set.of(typeCountri));
+
+        underTest.saveAll(List.of(catalogEntry1, catalogEntry2, catalogEntry3, catalogEntry4, catalogEntry5));
+
+
+    }
+
+    @AfterEach
+    void tearDown() {
+        underTest.deleteAll();
+    }
+
+    @Test
+    void itShouldReturnAll() {
+        // given
+        String name = "";
+        String country = "";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(5);
+    }
+
+    @Test
+    void testName() {
+        // given
+        String name = "first";
+        String country = "";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry4));
+    }
+
+    @Test
+    void testWildcardCharacterName() {
+        // given
+        String name = "se_ond";
+        String country = "";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(3);
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+        assertTrue(filterResult.contains(catalogEntry5));
+    }
+
+    @Test
+    void testWildcardCharactersName() {
+        // given
+        String name = "twe%";
+        String country = "";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(3);
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+        assertTrue(filterResult.contains(catalogEntry4));
+    }
+
+    @Test
+    void testCountry() {
+        // given
+        String name = "";
+        String country = "aaa";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(3);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+    }
+
+    @Test
+    void testWildcardCharacterCountry() {
+        // given
+        String name = "";
+        String country = "d_d";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry4));
+    }
+
+    @Test
+    void testWildcardCharactersCountry() {
+        // given
+        String name = "";
+        String country = "b%b";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry4));
+    }
+
+
+    @Test
+    void testType() {
+        // given
+        String name = "";
+        String country = "";
+        String type = "city";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry2));
+    }
+
+    @Test
+    void testWildcardCharacterType() {
+        // given
+        String name = "";
+        String country = "";
+        String type = "countr_";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(5);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+        assertTrue(filterResult.contains(catalogEntry4));
+        assertTrue(filterResult.contains(catalogEntry5));
+    }
+
+    @Test
+    void testWildcardCharactersType() {
+        // given
+        String name = "";
+        String country = "";
+        String type = "%city%";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(3);
+        assertTrue(filterResult.contains(catalogEntry1));
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+    }
+
+    @Test
+    void testNameAndCountry() {
+        // given
+        String name = "third";
+        String country = "aaa";
+        String type = "";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry2));
+        assertTrue(filterResult.contains(catalogEntry3));
+    }
+
+    @Test
+    void testNameAndType() {
+        // given
+        String name = "third";
+        String country = "";
+        String type = "countri";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(2);
+        assertTrue(filterResult.contains(catalogEntry3));
+        assertTrue(filterResult.contains(catalogEntry5));
+    }
+
+    @Test
+    void testCountryAndType() {
+        // given
+        String name = "";
+        String country = "ddd";
+        String type = "country";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(1);
+        assertTrue(filterResult.contains(catalogEntry4));
+    }
+
+    @Test
+    void testAll() {
+        // given
+        String name = "third";
+        String country = "AAA";
+        String type = "countri";
+
+        // when
+        Set<CatalogEntry> filterResult = underTest.filterCatalog(name, country, type);
+
+        // then
+        assertThat(filterResult.size()).isEqualTo(1);
+        assertTrue(filterResult.contains(catalogEntry3));
+    }
+}

backend/src/test/java/cz/zcu/kiv/backendapi/titlepage/TitlePageServiceImplementationTest.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.titlepage;
+
+import cz.zcu.kiv.backendapi.type.Type;
+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 static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TitlePageServiceImplementationTest {
+
+    @Mock
+    private TitlePageRepository titlePageRepository;
+
+    private TitlePageServiceImplementation underTest;
+
+    @BeforeEach
+    void setUp() {
+        underTest = new TitlePageServiceImplementation(titlePageRepository);
+    }
+
+    @Test
+    void testAddTitlePage() {
+        // given
+        long id = 1;
+        TitlePage titlePage = new TitlePage();
+        titlePage.setTitle("title");
+        titlePage.setContent("content");
+
+        // when
+
+        underTest.addOrUpdateTitlePage(id, titlePage);
+
+        // then
+        ArgumentCaptor<TitlePage> argumentCaptor = ArgumentCaptor.forClass(TitlePage.class);
+
+        verify(titlePageRepository).save(argumentCaptor.capture());
+
+        TitlePage capturedTitlePage = argumentCaptor.getValue();
+
+        titlePage.setId(id);
+
+        assertThat(capturedTitlePage).isEqualTo(titlePage);
+
+    }
+}

backend/src/test/java/cz/zcu/kiv/backendapi/type/TypeServiceImplTest.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.type;
+
+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 static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class TypeServiceImplTest {
+
+    @Mock
+    private TypeRepository typeRepository;
+
+    private TypeServiceImpl underTest;
+
+    @BeforeEach
+    void setUp() {
+        underTest = new TypeServiceImpl(typeRepository);
+    }
+
+    @Test
+    void saveType() {
+        // when
+        Type type = new Type("type");
+        underTest.saveType(type);
+
+        // then
+        ArgumentCaptor<Type> argumentCaptor = ArgumentCaptor.forClass(Type.class);
+
+        verify(typeRepository).save(argumentCaptor.capture());
+
+        Type capturedType = argumentCaptor.getValue();
+
+        assertThat(capturedType).isEqualTo(type);
+    }
+
+    @Test
+    void getTypeByName() {
+        // when
+        String typeName = "type";
+        underTest.getTypeByName(typeName);
+
+        // then
+        verify(typeRepository).findById(typeName);
+    }
+}

backend/src/test/java/cz/zcu/kiv/backendapi/user/UserRepositoryTest.java

@@ +1 @@
+package cz.zcu.kiv.backendapi.user;
+
+import org.junit.jupiter.api.AfterEach;
+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.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@DataJpaTest
+class UserRepositoryTest {
+
+    @Autowired
+    private UserRepository underTest;
+
+    @AfterEach
+    void tearDown() {
+        underTest.deleteAll();
+    }
+
+    @Test
+    void itShouldFindByEmail() {
+        // given
+        String email = "[e-mail]";
+        UserEntity userEntity = new UserEntity("User", email, "password", (byte) 0, false);
+        underTest.save(userEntity);
+
+        // when
+        Optional<UserEntity> userFoundByEmail = underTest.findByEmail(email);
+
+        // then
+        assertTrue(userFoundByEmail.isPresent());
+    }
+
+    @Test
+    void itShouldNotFindByEmail() {
+        // given
+        String email = "[e-mail]";
+
+        // when
+        Optional<UserEntity> userFoundByEmail = underTest.findByEmail(email);
+
+        // then
+        assertTrue(userFoundByEmail.isEmpty());
+    }
+}

backend/src/test/resources/application.properties

@@ +1 @@
+spring.datasource.url=jdbc:h2://mem:db;DB_CLOSE_DELAY=-1
+spring.datasource.username=sa
+spring.datasource.password=sa
+spring.datasource.driver-class-name=org.h2.Driver
+
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.generate-ddl=true
+spring.jpa.open-in-view=false
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect
+spring.jpa.properties.hibernate.format_sql=true
+spring.jpa.show-sql=true
+