implement PrivilegeServiceTest

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;
 

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<Role> 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 + '}'; }
-	 */
-
 }

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<Privilege> 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; }
-	 */
-
 }

src/main/java/org/springframework/samples/petclinic/repository/PrivilegeRepository.java

@@ -48,4 +48,11 @@ public interface PrivilegeRepository extends Repository<Privilege, Integer> {
 	 */
 	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);
+
 }

src/main/java/org/springframework/samples/petclinic/service/common/PrivilegeService.java

@@ -88,6 +88,13 @@ public class PrivilegeService implements BaseService<Privilege, PrivilegeDTO> {
 		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));
 	}

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<PrivilegeDTO> 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<PrivilegeDTO> expected = privilegeService.findAll();
+
+		privilegeDTO.setRoles(new HashSet<>());
+		assertThat(expected).doesNotContain(privilegeDTO);
+		PrivilegeDTO saved = privilegeService.save(privilegeDTO);
+		expected.add(saved);
+
+		List<PrivilegeDTO> 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<PrivilegeDTO> 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);
+	}
+
+}

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<Privilege> expected = new ArrayList<>();
+		List<PrivilegeDTO> privilegeDTOS = privilegeService.findAll();
+		privilegeDTOS.forEach(dto -> expected.add(privilegeService.dtoToEntity(dto)));
+		List<Privilege> 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<PrivilegeDTO> expected = privilegeService.findAll();
+		List<Privilege> privileges = new ArrayList<>();
+		expected.forEach(dto -> privileges.add(privilegeService.dtoToEntity(dto)));
+
+		List<PrivilegeDTO> 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<PrivilegeDTO> 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<PrivilegeDTO> expected = privilegeService.findAll();
+
+		privilegeDTO.setRoles(new HashSet<>());
+		assertThat(expected).doesNotContain(privilegeDTO);
+		PrivilegeDTO saved = privilegeService.save(privilegeDTO);
+		expected.add(saved);
+
+		List<PrivilegeDTO> 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<PrivilegeDTO> 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);
+	}
+
+}

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<RoleDTO> 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<RoleDTO> expected = roleService.findAll();
+		roleDTO.setUsers(new HashSet<>());
+
+		assertThat(expected).doesNotContain(roleDTO);
+
+		RoleDTO saved = roleService.save(roleDTO);
+		expected.add(saved);
+		List<RoleDTO> 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<RoleDTO> 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);
+	}
+
+}

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<RoleDTO> 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<RoleDTO> 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<RoleDTO> 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);
 	}
 
 }