diff --git a/src/main/java/org/springframework/samples/petclinic/common/CommonParameter.java b/src/main/java/org/springframework/samples/petclinic/common/CommonParameter.java index d0fd989f3..bbfa69347 100644 --- a/src/main/java/org/springframework/samples/petclinic/common/CommonParameter.java +++ b/src/main/java/org/springframework/samples/petclinic/common/CommonParameter.java @@ -30,15 +30,15 @@ public class CommonParameter { public static final String PHONE_REGEXP = "^(?:(?:\\+|00)33[\\s.-]{0,3}(?:\\(0\\)[\\s.-]{0,3})?|0)[1-9](?:(?:[\\s.-]?\\d{2}){4}|\\d{2}(?:[\\s.-]?\\d{3}){2}|)$"; + public static final int PRIVILEGE_MAX = 20; + public static final int STATUS_MAX = 10; public static final int STREET_MAX = 50; public static final int TOKEN_EXPIRATION = 60 * 24; - public static final int ROLE_MAX = 10; - - public static final int PRIVILEGE_MAX = 10; + public static final int ROLE_MAX = 20; public static final int ZIP_MAX = 6; diff --git a/src/main/java/org/springframework/samples/petclinic/model/common/Privilege.java b/src/main/java/org/springframework/samples/petclinic/model/common/Privilege.java index 06fa0515a..db0cb6bd8 100644 --- a/src/main/java/org/springframework/samples/petclinic/model/common/Privilege.java +++ b/src/main/java/org/springframework/samples/petclinic/model/common/Privilege.java @@ -19,7 +19,7 @@ import java.util.Collection; public class Privilege implements Serializable { @Id - @GeneratedValue(strategy = GenerationType.AUTO) + @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @NotNull @@ -31,20 +31,4 @@ public class Privilege implements Serializable { @ManyToMany(mappedBy = "privileges", fetch = FetchType.EAGER) private Collection roles; - /* - * @Override public boolean equals(Object o) { if (this == o) return true; if (!(o - * instanceof Role)) return false; - * - * Privilege privilege = (Privilege) o; - * - * if (!getId().equals(privilege.getId())) return false; if - * (!getName().equals(privilege.getName())) return false; - * - * return getRoles() != null ? getRoles().equals(privilege.getRoles()) : - * privilege.getRoles() == null; } - * - * @Override public String toString() { return "Privilege{" + "id=" + id + ", name='" - * + name + '\'' + ", roles=" + roles + '}'; } - */ - } diff --git a/src/main/java/org/springframework/samples/petclinic/model/common/Role.java b/src/main/java/org/springframework/samples/petclinic/model/common/Role.java index 587ba4851..c77d8ad72 100644 --- a/src/main/java/org/springframework/samples/petclinic/model/common/Role.java +++ b/src/main/java/org/springframework/samples/petclinic/model/common/Role.java @@ -45,17 +45,4 @@ public class Role implements Serializable { inverseJoinColumns = @JoinColumn(name = "privilege_id", referencedColumnName = "id")) private Collection privileges; - /* - * @Override public boolean equals(Object o) { if (this == o) return true; if (!(o - * instanceof Role)) return false; - * - * Role role = (Role) o; - * - * if (!getId().equals(role.getId())) return false; if - * (!getName().equals(role.getName())) return false; if (getUsers() == null && - * role.getUsers() != null) return false; if (getUsers() != null && role.getUsers() == - * null) return false; return getPrivileges() != null ? - * getPrivileges().equals(role.getPrivileges()) : role.getPrivileges() == null; } - */ - } diff --git a/src/main/java/org/springframework/samples/petclinic/repository/PrivilegeRepository.java b/src/main/java/org/springframework/samples/petclinic/repository/PrivilegeRepository.java index 9b6c5a6bc..eda7238e9 100644 --- a/src/main/java/org/springframework/samples/petclinic/repository/PrivilegeRepository.java +++ b/src/main/java/org/springframework/samples/petclinic/repository/PrivilegeRepository.java @@ -48,4 +48,11 @@ public interface PrivilegeRepository extends Repository { */ Privilege save(Privilege privilege); + /** + * Delete a {@link Privilege} to the data store. + * @param privilege the {@link Privilege} to delete + * @return the {@link Privilege} deleted + */ + Privilege delete(Privilege privilege); + } diff --git a/src/main/java/org/springframework/samples/petclinic/service/common/PrivilegeService.java b/src/main/java/org/springframework/samples/petclinic/service/common/PrivilegeService.java index 02fed4c52..dae5c7f64 100644 --- a/src/main/java/org/springframework/samples/petclinic/service/common/PrivilegeService.java +++ b/src/main/java/org/springframework/samples/petclinic/service/common/PrivilegeService.java @@ -88,6 +88,13 @@ public class PrivilegeService implements BaseService { return entityToDTO(privilege); } + public PrivilegeDTO delete(PrivilegeDTO dto) { + Privilege privilege = dtoToEntity(dto); + privilege = privilegeRepository.delete(privilege); + + return entityToDTO(privilege); + } + public PrivilegeDTO findByName(String name) { return entityToDTO(privilegeRepository.findByName(name)); } diff --git a/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceIntegrationTest.java b/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceIntegrationTest.java new file mode 100644 index 000000000..f78333566 --- /dev/null +++ b/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceIntegrationTest.java @@ -0,0 +1,156 @@ +package org.springframework.samples.petclinic.service.common; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.samples.petclinic.dto.common.PrivilegeDTO; +import org.springframework.samples.petclinic.dto.common.RoleDTO; +import org.springframework.samples.petclinic.dto.common.UserDTO; +import org.springframework.samples.petclinic.model.common.Privilege; +import org.springframework.samples.petclinic.model.common.Role; +import org.springframework.samples.petclinic.model.common.User; +import org.springframework.samples.petclinic.repository.PrivilegeRepository; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.Collections; +import java.util.HashSet; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@AutoConfigureTestDatabase +@SpringBootTest +@RunWith(SpringRunner.class) +class PrivilegeServiceIntegrationTest { + + private final static Integer USER_ID = 2; + + private final static Integer ROLE_ID = 4; + + private final static Integer PRIVILEGE_ID = 5; + + private final static String PRIVILEGE_NAME = "TEST_UPDATE"; + + private final static String ROLE_NAME = "ROLE_TEST"; + + @Autowired + private UserService userService; + + @Autowired + private RoleService roleService; + + @Autowired + private PrivilegeRepository privilegeRepository; + + private PrivilegeService privilegeService; + + private Role role; + + private RoleDTO roleDTO; + + private Privilege privilege; + + private PrivilegeDTO privilegeDTO; + + @BeforeEach + void beforeEach() { + privilegeService = new PrivilegeService(privilegeRepository); + privilege = new Privilege(); + privilegeDTO = new PrivilegeDTO(); + role = new Role(); + roleDTO = new RoleDTO(); + + UserDTO userDTO = userService.findById(USER_ID); + User user = userService.dtoToEntity(userDTO); + + privilege.setId(PRIVILEGE_ID); + privilege.setName(PRIVILEGE_NAME); + privilege.setRoles(Collections.singleton(role)); + + privilegeDTO.setId(PRIVILEGE_ID); + privilegeDTO.setName(PRIVILEGE_NAME); + privilegeDTO.setRoles(Collections.singleton(roleDTO)); + + role.setId(ROLE_ID); + role.setName(ROLE_NAME); + role.setUsers(Collections.singleton(user)); + role.setPrivileges(Collections.singleton(privilege)); + user.setRoles(Collections.singleton(role)); + + roleDTO.setId(ROLE_ID); + roleDTO.setName(ROLE_NAME); + roleDTO.setUsers(Collections.singleton(userDTO)); + roleDTO.setPrivileges(Collections.singleton(privilegeDTO)); + userDTO.setRoles(Collections.singleton(roleDTO)); + } + + @Test + @Tag("findById") + @DisplayName("Verify that we get PrivilegeDTO by his ID") + void findById() { + List privilegeDTOS = privilegeService.findAll(); + PrivilegeDTO expected = privilegeDTOS.get(2); + + PrivilegeDTO found = privilegeService.findById(expected.getId()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.getRoles().toArray(new RoleDTO[0])); + } + + @Test + @Tag("findAll") + @DisplayName("Verify that the PrivilegeDTO list contain all previous elements and the new saved one") + void findAll() { + List expected = privilegeService.findAll(); + + privilegeDTO.setRoles(new HashSet<>()); + assertThat(expected).doesNotContain(privilegeDTO); + PrivilegeDTO saved = privilegeService.save(privilegeDTO); + expected.add(saved); + + List found = privilegeService.findAll(); + + assertThat(found).usingElementComparatorOnFields("name").containsOnlyOnceElementsOf(expected); + + privilegeService.delete(saved); + } + + @Test + @Tag("findByName") + @DisplayName("Verify that we get PrivilegeDTO by his Name") + void findByName() { + PrivilegeDTO expected = privilegeService.findById(1); + + PrivilegeDTO found = privilegeService.findByName(expected.getName()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.getRoles().toArray(new RoleDTO[0])); + + } + + @Test + @Tag("save") + @DisplayName("Verify that all PrivilegeDTO list contain the new saved one") + void save() { + List expected = privilegeService.findAll(); + + assertThat(expected).doesNotContain(privilegeDTO); + + privilegeDTO.setRoles(new HashSet<>()); + PrivilegeDTO saved = privilegeService.save(privilegeDTO); + + assertThat(saved).isEqualToIgnoringGivenFields(privilegeDTO, "id", "roles"); + assertThat(saved.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(saved.getRoles().toArray(new RoleDTO[0])); + + privilegeService.delete(saved); + } + +} diff --git a/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceTest.java b/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceTest.java new file mode 100644 index 000000000..021f51329 --- /dev/null +++ b/src/test/java/org/springframework/samples/petclinic/service/common/PrivilegeServiceTest.java @@ -0,0 +1,215 @@ +package org.springframework.samples.petclinic.service.common; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.samples.petclinic.dto.common.PrivilegeDTO; +import org.springframework.samples.petclinic.dto.common.RoleDTO; +import org.springframework.samples.petclinic.dto.common.UserDTO; +import org.springframework.samples.petclinic.model.common.Privilege; +import org.springframework.samples.petclinic.model.common.Role; +import org.springframework.samples.petclinic.model.common.User; +import org.springframework.samples.petclinic.repository.PrivilegeRepository; +import org.springframework.samples.petclinic.repository.RoleRepository; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; + +@AutoConfigureTestDatabase +@SpringBootTest +@RunWith(SpringRunner.class) +class PrivilegeServiceTest { + + private final static Integer USER_ID = 2; + + private final static Integer ROLE_ID = 4; + + private final static Integer PRIVILEGE_ID = 5; + + private final static String PRIVILEGE_NAME = "TEST_UPDATE"; + + private final static String ROLE_NAME = "ROLE_TEST"; + + @Autowired + private UserService userService; + + @Autowired + private RoleService roleService; + + @Autowired + private PrivilegeRepository privilegeRepository; + + private PrivilegeService privilegeService; + + private Role role; + + private RoleDTO roleDTO; + + private Privilege privilege; + + private PrivilegeDTO privilegeDTO; + + @BeforeEach + void beforeEach() { + privilegeService = new PrivilegeService(privilegeRepository); + privilege = new Privilege(); + privilegeDTO = new PrivilegeDTO(); + role = new Role(); + roleDTO = new RoleDTO(); + + UserDTO userDTO = userService.findById(USER_ID); + User user = userService.dtoToEntity(userDTO); + + privilege.setId(PRIVILEGE_ID); + privilege.setName(PRIVILEGE_NAME); + privilege.setRoles(Collections.singleton(role)); + + privilegeDTO.setId(PRIVILEGE_ID); + privilegeDTO.setName(PRIVILEGE_NAME); + privilegeDTO.setRoles(Collections.singleton(roleDTO)); + + role.setId(ROLE_ID); + role.setName(ROLE_NAME); + role.setUsers(Collections.singleton(user)); + role.setPrivileges(Collections.singleton(privilege)); + user.setRoles(Collections.singleton(role)); + + roleDTO.setId(ROLE_ID); + roleDTO.setName(ROLE_NAME); + roleDTO.setUsers(Collections.singleton(userDTO)); + roleDTO.setPrivileges(Collections.singleton(privilegeDTO)); + userDTO.setRoles(Collections.singleton(roleDTO)); + } + + @Test + @Tag("dtoToEntity") + @DisplayName("Verify the convertion from DTO to Entity") + void dtoToEntity() { + Privilege found = privilegeService.dtoToEntity(privilegeDTO); + + assertThat(found).isEqualToIgnoringGivenFields(privilegeDTO, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges").contains(role); + } + + @Test + @Tag("entityToDTO") + @DisplayName("Verify the convertion from Entity to DTO") + void entityToDTO() { + PrivilegeDTO found = privilegeService.entityToDTO(privilege); + + assertThat(found).isEqualToIgnoringGivenFields(privilegeDTO, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges").contains(roleDTO); + } + + @Test + @Tag("dtosToEntities") + @DisplayName("Verify the convertion from DTOs list to Entities list") + void dtosToEntities() { + List expected = new ArrayList<>(); + List privilegeDTOS = privilegeService.findAll(); + privilegeDTOS.forEach(dto -> expected.add(privilegeService.dtoToEntity(dto))); + List found = privilegeService.dtosToEntities(privilegeDTOS); + + assertThat(found).hasSameSizeAs(expected); + + for (int i = 0; i < found.size(); i++) { + assertThat(found.get(i)).isEqualToIgnoringGivenFields(expected.get(i), "roles"); + assertThat(found.get(i).getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.get(i).getRoles().toArray(new Role[0])); + } + } + + @Test + @Tag("entitiesToDTOS") + @DisplayName("Verify the convertion from Entities list to DTOs list") + void entitiesToDTOS() { + List expected = privilegeService.findAll(); + List privileges = new ArrayList<>(); + expected.forEach(dto -> privileges.add(privilegeService.dtoToEntity(dto))); + + List found = privilegeService.entitiesToDTOS(privileges); + + assertThat(found).hasSameSizeAs(expected); + + for (int i = 0; i < found.size(); i++) { + assertThat(found.get(i)).isEqualToIgnoringGivenFields(expected.get(i), "roles"); + assertThat(found.get(i).getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.get(i).getRoles().toArray(new RoleDTO[0])); + } + } + + @Test + @Tag("findById") + @DisplayName("Verify that we get PrivilegeDTO by his ID") + void findById() { + List privilegeDTOS = privilegeService.findAll(); + PrivilegeDTO expected = privilegeDTOS.get(2); + + PrivilegeDTO found = privilegeService.findById(expected.getId()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.getRoles().toArray(new RoleDTO[0])); + } + + @Test + @Tag("findAll") + @DisplayName("Verify that the PrivilegeDTO list contain all previous elements and the new saved one") + void findAll() { + List expected = privilegeService.findAll(); + + privilegeDTO.setRoles(new HashSet<>()); + assertThat(expected).doesNotContain(privilegeDTO); + PrivilegeDTO saved = privilegeService.save(privilegeDTO); + expected.add(saved); + + List found = privilegeService.findAll(); + + assertThat(found).usingElementComparatorOnFields("name").containsOnlyOnceElementsOf(expected); + + privilegeService.delete(saved); + } + + @Test + @Tag("findByName") + @DisplayName("Verify that we get PrivilegeDTO by his Name") + void findByName() { + PrivilegeDTO expected = privilegeService.findById(1); + + PrivilegeDTO found = privilegeService.findByName(expected.getName()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "roles"); + assertThat(found.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(expected.getRoles().toArray(new RoleDTO[0])); + + } + + @Test + @Tag("save") + @DisplayName("Verify that all PrivilegeDTO list contain the new saved one") + void save() { + List expected = privilegeService.findAll(); + + assertThat(expected).doesNotContain(privilegeDTO); + + privilegeDTO.setRoles(new HashSet<>()); + PrivilegeDTO saved = privilegeService.save(privilegeDTO); + + assertThat(saved).isEqualToIgnoringGivenFields(privilegeDTO, "id", "roles"); + assertThat(saved.getRoles()).usingElementComparatorIgnoringFields("users", "privileges") + .contains(saved.getRoles().toArray(new RoleDTO[0])); + + privilegeService.delete(saved); + } + +} diff --git a/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceIntegrationTest.java b/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceIntegrationTest.java new file mode 100644 index 000000000..948398dba --- /dev/null +++ b/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceIntegrationTest.java @@ -0,0 +1,149 @@ +package org.springframework.samples.petclinic.service.common; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Tag; +import org.junit.jupiter.api.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.samples.petclinic.dto.common.PrivilegeDTO; +import org.springframework.samples.petclinic.dto.common.RoleDTO; +import org.springframework.samples.petclinic.dto.common.UserDTO; +import org.springframework.samples.petclinic.model.common.Privilege; +import org.springframework.samples.petclinic.model.common.Role; +import org.springframework.samples.petclinic.model.common.User; +import org.springframework.samples.petclinic.repository.RoleRepository; +import org.springframework.test.context.junit4.SpringRunner; + +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; + +@AutoConfigureTestDatabase +@SpringBootTest +@RunWith(SpringRunner.class) +class RoleServiceIntegrationTest { + + private final static Integer USER_ID = 2; + + private final static Integer ROLE_ID = 4; + + private final static Integer PRIVILEGE_ID = 3; + + private final static String ROLE_NAME = "ROLE_TEST"; + + @Autowired + private RoleRepository roleRepository; + + @Autowired + private UserService userService; + + @Autowired + private PrivilegeService privilegeService; + + private RoleService roleService; + + private Role role; + + private RoleDTO roleDTO; + + private Privilege privilege; + + private PrivilegeDTO privilegeDTO; + + @BeforeEach + void beforeEach() { + roleService = new RoleService(roleRepository); + + UserDTO userDTO = userService.findById(USER_ID); + User user = userService.dtoToEntity(userDTO); + privilegeDTO = privilegeService.findById(PRIVILEGE_ID); + privilege = privilegeService.dtoToEntity(privilegeDTO); + + role = new Role(); + role.setId(ROLE_ID); + role.setName(ROLE_NAME); + role.setUsers(Collections.singleton(user)); + role.setPrivileges(Collections.singleton(privilege)); + user.setRoles(Collections.singleton(role)); + + roleDTO = new RoleDTO(); + roleDTO.setId(ROLE_ID); + roleDTO.setName(ROLE_NAME); + roleDTO.setUsers(Collections.singleton(userDTO)); + roleDTO.setPrivileges(Collections.singleton(privilegeDTO)); + userDTO.setRoles(Collections.singleton(roleDTO)); + } + + @Test + @Tag("findById") + @DisplayName("Verify that we get RoleDTO by his ID") + void findById() { + List allDTO = roleService.findAll(); + RoleDTO expected = allDTO.get(2); + + RoleDTO found = roleService.findById(expected.getId()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "users", "privileges"); + assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles") + .contains(expected.getUsers().toArray(new UserDTO[0])); + assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles") + .contains(expected.getPrivileges().toArray(new PrivilegeDTO[0])); + } + + @Test + @Tag("findAll") + @DisplayName("Verify that the RoleDTO list contain all previous elements and the new saved one") + void findAll() { + List expected = roleService.findAll(); + roleDTO.setUsers(new HashSet<>()); + + assertThat(expected).doesNotContain(roleDTO); + + RoleDTO saved = roleService.save(roleDTO); + expected.add(saved); + List found = roleService.findAll(); + + assertThat(found).usingElementComparatorOnFields("id", "name").containsOnlyOnceElementsOf(expected); + + roleService.delete(saved); + } + + @Test + @Tag("findByName") + @DisplayName("Verify that we get RoleDTO by his Name") + void findByName() { + RoleDTO expected = roleService.findById(1); + + RoleDTO found = roleService.findByName(expected.getName()); + + assertThat(found).isEqualToIgnoringGivenFields(expected, "users", "privileges"); + assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles") + .contains(expected.getUsers().toArray(new UserDTO[0])); + assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles") + .contains(expected.getPrivileges().toArray(new PrivilegeDTO[0])); + + } + + @Test + @Tag("save") + @DisplayName("Verify that all RoleDTO list contain the new saved one") + void save() { + Collection expected = roleService.findAll(); + assertThat(expected).doesNotContain(roleDTO); + + roleDTO.setUsers(new HashSet<>()); + RoleDTO saved = roleService.save(roleDTO); + + assertThat(saved).isEqualToIgnoringGivenFields(roleDTO, "id", "users", "privileges"); + assertThat(saved.getUsers()).usingElementComparatorIgnoringFields("roles") + .contains(roleDTO.getUsers().toArray(new UserDTO[0])); + assertThat(saved.getPrivileges()).usingElementComparatorIgnoringFields("roles") + .contains(roleDTO.getPrivileges().toArray(new PrivilegeDTO[0])); + + roleService.delete(saved); + } + +} diff --git a/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceTest.java b/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceTest.java index d1dddeb6a..5b24e75d0 100644 --- a/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceTest.java +++ b/src/test/java/org/springframework/samples/petclinic/service/common/RoleServiceTest.java @@ -14,10 +14,7 @@ import org.springframework.samples.petclinic.model.common.User; import org.springframework.samples.petclinic.repository.RoleRepository; import org.springframework.test.context.junit4.SpringRunner; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; +import java.util.*; import static org.assertj.core.api.Assertions.assertThat; @@ -59,12 +56,13 @@ class RoleServiceTest { @BeforeEach void beforeEach() { + roleService = new RoleService(roleRepository); + userDTO = userService.findById(USER_ID); user = userService.dtoToEntity(userDTO); privilegeDTO = privilegeService.findById(PRIVILEGE_ID); privilege = privilegeService.dtoToEntity(privilegeDTO); - roleService = new RoleService(roleRepository); role = new Role(); role.setId(ROLE_ID); role.setName(ROLE_NAME); @@ -86,8 +84,7 @@ class RoleServiceTest { void dtoToEntity() { Role found = roleService.dtoToEntity(roleDTO); - assertThat(found.getId()).isEqualTo(role.getId()); - assertThat(found.getName()).isEqualTo(role.getName()); + assertThat(found).isEqualToIgnoringGivenFields(role, "users", "privileges"); assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles").contains(user); assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles").contains(privilege); } @@ -98,8 +95,7 @@ class RoleServiceTest { void entityToDTO() { RoleDTO found = roleService.entityToDTO(role); - assertThat(found.getId()).isEqualTo(roleDTO.getId()); - assertThat(found.getName()).isEqualTo(roleDTO.getName()); + assertThat(found).isEqualToIgnoringGivenFields(role, "users", "privileges"); assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles").contains(userDTO); assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles").contains(privilegeDTO); } @@ -116,8 +112,7 @@ class RoleServiceTest { assertThat(found).hasSameSizeAs(expected); for (int i = 0; i < found.size(); i++) { - assertThat(found.get(i).getId()).isEqualTo(expected.get(i).getId()); - assertThat(found.get(i).getName()).isEqualTo(expected.get(i).getName()); + assertThat(found.get(i)).isEqualToIgnoringGivenFields(expected.get(i), "users", "privileges"); assertThat(found.get(i).getUsers()).usingElementComparatorIgnoringFields("roles") .contains(expected.get(i).getUsers().toArray(new User[0])); assertThat(found.get(i).getPrivileges()).usingElementComparatorIgnoringFields("roles") @@ -138,8 +133,7 @@ class RoleServiceTest { assertThat(found).hasSameSizeAs(expected); for (int i = 0; i < found.size(); i++) { - assertThat(found.get(i).getId()).isEqualTo(expected.get(i).getId()); - assertThat(found.get(i).getName()).isEqualTo(expected.get(i).getName()); + assertThat(found.get(i)).isEqualToIgnoringGivenFields(expected.get(i), "users", "privileges"); assertThat(found.get(i).getUsers()).usingElementComparatorIgnoringFields("roles") .contains(expected.get(i).getUsers().toArray(new UserDTO[0])); assertThat(found.get(i).getPrivileges()).usingElementComparatorIgnoringFields("roles") @@ -156,8 +150,7 @@ class RoleServiceTest { RoleDTO found = roleService.findById(expected.getId()); - assertThat(found.getId()).isEqualTo(expected.getId()); - assertThat(found.getName()).isEqualTo(expected.getName()); + assertThat(found).isEqualToIgnoringGivenFields(expected, "users", "privileges"); assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles") .contains(expected.getUsers().toArray(new UserDTO[0])); assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles") @@ -169,15 +162,15 @@ class RoleServiceTest { @DisplayName("Verify that the RoleDTO list contain all previous elements and the new saved one") void findAll() { List expected = roleService.findAll(); - roleDTO.setUsers(new HashSet<>()); - assertThat(expected).doesNotContain(roleDTO); - RoleDTO saved = roleService.save(roleDTO); + assertThat(expected).doesNotContain(roleDTO); + + RoleDTO saved = roleService.save(roleDTO); + expected.add(saved); List found = roleService.findAll(); - assertThat(found).hasSize(expected.size() + 1).usingElementComparatorOnFields("id", "name") - .containsOnlyOnceElementsOf(expected).contains(roleDTO); + assertThat(found).usingElementComparatorOnFields("id", "name").containsOnlyOnceElementsOf(expected); roleService.delete(saved); } @@ -190,8 +183,7 @@ class RoleServiceTest { RoleDTO found = roleService.findByName(expected.getName()); - assertThat(found.getId()).isEqualTo(expected.getId()); - assertThat(found.getName()).isEqualTo(expected.getName()); + assertThat(found).isEqualToIgnoringGivenFields(expected, "users", "privileges"); assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles") .contains(expected.getUsers().toArray(new UserDTO[0])); assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles") @@ -203,19 +195,20 @@ class RoleServiceTest { @Tag("save") @DisplayName("Verify that all RoleDTO list contain the new saved one") void save() { - assertThat(roleService.findAll()).doesNotContain(roleDTO); + Collection expected = roleService.findAll(); + assertThat(expected).doesNotContain(roleDTO); + + roleDTO.setId(expected.size() + 1); roleDTO.setUsers(new HashSet<>()); RoleDTO saved = roleService.save(roleDTO); - RoleDTO found = roleService.findById(saved.getId()); - assertThat(found.getId()).isEqualTo(saved.getId()); - assertThat(found.getName()).isEqualTo(saved.getName()); - assertThat(found.getUsers()).usingElementComparatorIgnoringFields("roles") - .contains(saved.getUsers().toArray(new UserDTO[0])); - assertThat(found.getPrivileges()).usingElementComparatorIgnoringFields("roles") - .contains(saved.getPrivileges().toArray(new PrivilegeDTO[0])); + assertThat(saved).isEqualToIgnoringGivenFields(roleDTO, "id", "users", "privileges"); + assertThat(saved.getUsers()).usingElementComparatorIgnoringFields("roles") + .contains(roleDTO.getUsers().toArray(new UserDTO[0])); + assertThat(saved.getPrivileges()).usingElementComparatorIgnoringFields("roles") + .contains(roleDTO.getPrivileges().toArray(new PrivilegeDTO[0])); - RoleDTO deleted = roleService.delete(saved); + roleService.delete(saved); } }