From e4b38a57edefd99050b4aaf42e9f68552ef57565 Mon Sep 17 00:00:00 2001 From: Fredrik Marjoni Date: Sat, 28 Feb 2026 11:29:39 +0100 Subject: [PATCH] perf[User]: Improve User validation and update corresponding JUnit tests --- .../edu/group5/app/model/user/UserTest.java | 166 ++++++++++-------- 1 file changed, 92 insertions(+), 74 deletions(-) diff --git a/src/test/java/edu/group5/app/model/user/UserTest.java b/src/test/java/edu/group5/app/model/user/UserTest.java index 1e7277a..324e3a0 100644 --- a/src/test/java/edu/group5/app/model/user/UserTest.java +++ b/src/test/java/edu/group5/app/model/user/UserTest.java @@ -1,136 +1,154 @@ package edu.group5.app.model.user; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; public class UserTest { - private static final int TEST_USER_ID = 1; - private static final String TEST_ROLE = "Donor"; - private static final String TEST_FIRST_NAME = "John"; - private static final String TEST_LAST_NAME = "Doe"; - private static final String TEST_EMAIL = "john.doe@example.com"; - private static final String TEST_PASSWORD = "password123"; - private static final String TEST_PASSWORD_HASH = new BCryptPasswordEncoder().encode(TEST_PASSWORD); - private static final int WRONG_USER_ID = -5; - private static final String WRONG_ROLE = ""; - private static final String WRONG_FIRST_NAME = ""; - private static final String WRONG_LAST_NAME = ""; - private static final String WRONG_EMAIL = ""; - private static final String WRONG_PASSWORD_HASH = ""; + private int testUserId; + private String testRole; + private String testFirstName; + private String testLastName; + private String testEmail; + private String testPassword; + private String testPasswordHash; - private void constructorTest(int userId, String role, String firstName, String lastName, String email, String passwordHash, boolean negativeTest) { - boolean exceptionThrown = negativeTest; - try { - new User(userId, role, firstName, lastName, email, passwordHash); - } catch (Exception e) { - exceptionThrown = !negativeTest; - } finally { - assertFalse(exceptionThrown); - } + @BeforeEach + void setUp() { + testUserId = 1; + testRole = "Donor"; + testFirstName = "John"; + testLastName = "Doe"; + testEmail = "john.doe@example.com"; + testPassword = "password123"; + testPasswordHash = new BCryptPasswordEncoder().encode(testPassword); } - @Test - public void constructorThrowsNoException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, false); - } + private void constructorTest(int userId, String role, String firstName, + String lastName, String email, String passwordHash, + String expectedMessage) { + IllegalArgumentException exception = assertThrows( + IllegalArgumentException.class, + () -> new User(userId, role, firstName, lastName, email, passwordHash) + ); - @Test - public void constructorWithNegativeUserIdThrowsException() { - constructorTest(WRONG_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + assertEquals(expectedMessage, exception.getMessage()); } @Test - public void constructorWithEmptyRoleThrowsException() { - constructorTest(TEST_USER_ID, WRONG_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void constructorCreatesValidUser() { + User user = new User(testUserId, testRole, testFirstName, + testLastName, testEmail, testPasswordHash); + assertEquals(testUserId, user.getUserId()); + assertEquals(testRole, user.getRole()); + assertEquals(testFirstName, user.getFirstName()); + assertEquals(testLastName, user.getLastName()); + assertEquals(testEmail, user.getEmail()); + assertEquals(testPasswordHash, user.getPasswordHash()); } @Test - public void constructorWithEmptyFirstNameThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, WRONG_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void constructorWithNegativeUserIdThrowsException() { + constructorTest(-1, testRole, testFirstName, testLastName, + testEmail, testPasswordHash, "User ID must be positive"); } @Test - public void constructorWithEmptyLastNameThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, WRONG_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void constructorWithNullRoleThrowsException() { + constructorTest(testUserId, null, testFirstName, testLastName, + testEmail, testPasswordHash, "Role cannot be null or empty"); } @Test - public void constructorWithEmptyEmailThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, WRONG_EMAIL, TEST_PASSWORD_HASH, true); + void constructorWithEmptyRoleThrowsException() { + constructorTest(testUserId, "", testFirstName, testLastName, + testEmail, testPasswordHash, "Role cannot be null or empty"); } @Test - public void constructorWithEmptyPasswordHashThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, WRONG_PASSWORD_HASH, true); + void constructorWithNullFirstNameThrowsException() { + constructorTest(testUserId, testRole, null, testLastName, + testEmail, testPasswordHash, "First name cannot be null or empty"); } - private void getMethodComparer(User user, boolean negativeTest) { - if (user.getUserId() == TEST_USER_ID && - user.getRole().equals(TEST_ROLE) && - user.getFirstName().equals(TEST_FIRST_NAME) && - user.getLastName().equals(TEST_LAST_NAME) && - user.getEmail().equals(TEST_EMAIL) && - user.getPasswordHash() != null) { - assertFalse(negativeTest); - } + @Test + void constructorWithEmptyFirstNameThrowsException() { + constructorTest(testUserId, testRole, "", testLastName, + testEmail, testPasswordHash, "First name cannot be null or empty"); } @Test - public void getMethodsReturnCorrectInformation() { - User testUser = new User(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH); - getMethodComparer(testUser, false); + void constructorWithNullLastNameThrowsException() { + constructorTest(testUserId, testRole, testFirstName, null, + testEmail, testPasswordHash, "Last name cannot be null or empty"); } @Test - public void verifyPasswordReturnsTrueForCorrectPassword() { - User testUser = new User(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH); - assertTrue(testUser.verifyPassword(TEST_PASSWORD)); + void constructorWithEmptyLastNameThrowsException() { + constructorTest(testUserId, testRole, testFirstName, "", + testEmail, testPasswordHash, "Last name cannot be null or empty"); } @Test - public void verifyPasswordReturnsFalseForIncorrectPassword() { - User testUser = new User(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH); - assertFalse(testUser.verifyPassword("wrongPassword")); + void constructorWithNullEmailThrowsException() { + constructorTest(testUserId, testRole, testFirstName, testLastName, + null, testPasswordHash, "Email cannot be null or empty"); } @Test - public void verifyPasswordReturnsFalseForNullPassword() { - User testUser = new User(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH); - assertFalse(testUser.verifyPassword(null)); + void constructorWithEmptyEmailThrowsException() { + constructorTest(testUserId, testRole, testFirstName, testLastName, + "", testPasswordHash, "Email cannot be null or empty"); } @Test - public void verifyPasswordReturnsFalseForEmptyPassword() { - User testUser = new User(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH); - assertFalse(testUser.verifyPassword("")); + void constructorWithNullPasswordHashThrowsException() { + constructorTest(testUserId, testRole, testFirstName, testLastName, + testEmail, null, "Password hash cannot be null or empty"); } @Test - public void constructorWithNullRoleThrowsException() { - constructorTest(TEST_USER_ID, null, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void constructorWithEmptyPasswordHashThrowsException() { + constructorTest(testUserId, testRole, testFirstName, testLastName, + testEmail, "", "Password hash cannot be null or empty"); } + @Test - public void constructorWithNullFirstNameThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, null, TEST_LAST_NAME, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void verifyPasswordReturnsTrueForCorrectPassword() { + User user = new User(testUserId, testRole, testFirstName, + testLastName, testEmail, testPasswordHash); + + assertTrue(user.verifyPassword(testPassword)); } @Test - public void constructorWithNullLastNameThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, null, TEST_EMAIL, TEST_PASSWORD_HASH, true); + void verifyPasswordReturnsFalseForIncorrectPassword() { + User user = new User(testUserId, testRole, testFirstName, + testLastName, testEmail, testPasswordHash); + + assertFalse(user.verifyPassword("wrongPassword")); } @Test - public void constructorWithNullEmailThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, null, TEST_PASSWORD_HASH, true); + void verifyPasswordReturnsFalseForNullPassword() { + User user = new User(testUserId, testRole, testFirstName, + testLastName, testEmail, testPasswordHash); + + assertFalse(user.verifyPassword(null)); } @Test - public void constructorWithNullPasswordHashThrowsException() { - constructorTest(TEST_USER_ID, TEST_ROLE, TEST_FIRST_NAME, TEST_LAST_NAME, TEST_EMAIL, null, true); + void verifyPasswordReturnsFalseForEmptyPassword() { + User user = new User(testUserId, testRole, testFirstName, + testLastName, testEmail, testPasswordHash); + + assertFalse(user.verifyPassword("")); } -} +} \ No newline at end of file