From 587f9413878ade8f2e7ef4ddff7f6fd48138630f Mon Sep 17 00:00:00 2001 From: haavajor Date: Thu, 23 Apr 2026 02:09:01 +0200 Subject: [PATCH 1/3] Refactored unit tests, increased coverage, renamed unit test method names to be more consistent and accurate for the test being done --- .../java/application/user/UserLoginTest.java | 89 ++++++- .../application/user/UserRegisterTest.java | 72 +++--- .../java/application/user/UserSignInTest.java | 213 ++++++++++++++++ .../application/user/UserStatisticsTest.java | 98 +++++-- src/test/java/domain/DonationTest.java | 151 +++++++---- src/test/java/domain/OrganizationTest.java | 241 ++++++------------ src/test/java/domain/UserTest.java | 113 ++++---- 7 files changed, 634 insertions(+), 343 deletions(-) create mode 100644 src/test/java/application/user/UserSignInTest.java diff --git a/src/test/java/application/user/UserLoginTest.java b/src/test/java/application/user/UserLoginTest.java index 4bd8312..bce7003 100644 --- a/src/test/java/application/user/UserLoginTest.java +++ b/src/test/java/application/user/UserLoginTest.java @@ -2,6 +2,7 @@ import application.security.PasswordHasher; import domain.user.User; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import persistence.UserRepository; @@ -11,30 +12,41 @@ public class UserLoginTest { + private static final String USERNAME = "testuser"; + private static final String RAW_PASSWORD = "secret"; + private static final String HASHED_PASSWORD = "hashed-secret"; + private static final String EMAIL = "test@example.com"; + private static final String PHONE = "12345678"; + + private User user; + + @BeforeEach + void init() { + user = new User(USERNAME, PHONE, HASHED_PASSWORD, EMAIL); + } + @Test void executeReturnsUserWhenCredentialsAreValid() { - User user = new User("testuser", "12345678", "hashed-secret", "test@example.com"); - PasswordHasher hasher = new FakePasswordHasher("hashed-secret"); + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); UserRepository repo = new FakeUserRepository(Optional.of(user)); UserLogin userLogin = new UserLogin(hasher, repo); - User result = userLogin.execute("testuser", "secret"); + User result = userLogin.execute(USERNAME, RAW_PASSWORD); assertSame(user, result); - } @Test void executeThrowsWhenLoginDoesNotExist() { - PasswordHasher hasher = new FakePasswordHasher("hashed-secret"); + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); UserRepository repo = new FakeUserRepository(Optional.empty()); UserLogin userLogin = new UserLogin(hasher, repo); IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, - () -> userLogin.execute("missing-user", "secret") + () -> userLogin.execute("missing-user", RAW_PASSWORD) ); assertEquals("Invalid credentials", exception.getMessage()); @@ -42,7 +54,6 @@ void executeThrowsWhenLoginDoesNotExist() { @Test void executeThrowsWhenPasswordIsWrong() { - User user = new User("testuser", "12345678", "stored-hash", "test@example.com"); PasswordHasher hasher = new FakePasswordHasher("different-hash"); UserRepository repo = new FakeUserRepository(Optional.of(user)); @@ -50,7 +61,7 @@ void executeThrowsWhenPasswordIsWrong() { IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, - () -> userLogin.execute("testuser", "wrong-password") + () -> userLogin.execute(USERNAME, "wrong-password") ); assertEquals("Invalid password", exception.getMessage()); @@ -58,15 +69,39 @@ void executeThrowsWhenPasswordIsWrong() { @Test void executeUsesNormalizedLoginBeforeLookup() { - User user = new User("testuser", "12345678", "hashed-secret", "test@example.com"); RecordingUserRepository repo = new RecordingUserRepository(Optional.of(user)); - PasswordHasher hasher = new FakePasswordHasher("hashed-secret"); + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); + + UserLogin userLogin = new UserLogin(hasher, repo); + + userLogin.execute(" TestUser ", RAW_PASSWORD); + + assertEquals(USERNAME, repo.lastLoginUsed); + } + + @Test + void executeDoesNotHashPasswordWhenLoginDoesNotExist() { + TrackingPasswordHasher hasher = new TrackingPasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.empty()); UserLogin userLogin = new UserLogin(hasher, repo); - userLogin.execute(" TestUser ", "secret"); + assertThrows(IllegalArgumentException.class, + () -> userLogin.execute("missing-user", RAW_PASSWORD)); - assertEquals("testuser", repo.lastLoginUsed); + assertFalse(hasher.wasCalled); + } + + @Test + void executePassesRawPasswordToHasher() { + RecordingPasswordHasher hasher = new RecordingPasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.of(user)); + + UserLogin userLogin = new UserLogin(hasher, repo); + + userLogin.execute(USERNAME, RAW_PASSWORD); + + assertEquals(RAW_PASSWORD, hasher.lastPassword); } private static class FakePasswordHasher implements PasswordHasher{ @@ -157,6 +192,36 @@ public void insert(User user) { } } + private static class TrackingPasswordHasher implements PasswordHasher { + private final String hashToReturn; + private boolean wasCalled; + + private TrackingPasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + wasCalled = true; + return hashToReturn; + } + } + + private static class RecordingPasswordHasher implements PasswordHasher { + private final String hashToReturn; + private String lastPassword; + + private RecordingPasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + lastPassword = password; + return hashToReturn; + } + } + } diff --git a/src/test/java/application/user/UserRegisterTest.java b/src/test/java/application/user/UserRegisterTest.java index c5296cd..aae8e83 100644 --- a/src/test/java/application/user/UserRegisterTest.java +++ b/src/test/java/application/user/UserRegisterTest.java @@ -2,6 +2,7 @@ import application.security.PasswordHasher; import domain.user.User; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import persistence.UserRepository; @@ -11,47 +12,54 @@ public class UserRegisterTest { + + private static final String USERNAME = "testuser"; + private static final String PHONE = "12345678"; + private static final String PASSWORD = "secret"; + private static final String EMAIL = "test@example.com"; + private static final String HASHED_PASSWORD = "hashed-password"; + + private RecordingUserRepository repo; + private PasswordHasher hasher; + private UserRegister userRegister; + + @BeforeEach + void setUp() { + repo = new RecordingUserRepository(); + hasher = new FakePasswordHasher(HASHED_PASSWORD); + userRegister = new UserRegister(hasher, repo); + } + @Test void executeInsertsUserWhenInputIsValid() { - RecordingUserRepository repo = new RecordingUserRepository(); - PasswordHasher hasher = new FakePasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); - - userRegister.execute("testuser", "12345678", "secret", "test@example.com"); + userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL); assertNotNull(repo.insertedUser); - assertEquals("testuser", repo.insertedUser.getUsername()); - assertEquals("12345678", repo.insertedUser.getPhoneNumber()); - assertEquals("hashed-password", repo.insertedUser.getPassword()); - assertEquals("test@example.com", repo.insertedUser.getEMail()); + assertEquals(USERNAME, repo.insertedUser.getUsername()); + assertEquals(PHONE, repo.insertedUser.getPhoneNumber()); + assertEquals(HASHED_PASSWORD, repo.insertedUser.getPassword()); + assertEquals(EMAIL, repo.insertedUser.getEmail()); } @Test void executeNormalizesUsernameEmailAndPhoneBeforeInsert() { - RecordingUserRepository repo = new RecordingUserRepository(); - PasswordHasher hasher = new FakePasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); - - userRegister.execute(" testuser ", " 12345678 ", "secret", " TEST@EXAMPLE.COM "); + userRegister.execute(" testuser ", " 12345678 ", PASSWORD, " TEST@EXAMPLE.COM "); assertNotNull(repo.insertedUser); - assertEquals("testuser", repo.insertedUser.getUsername()); - assertEquals("12345678", repo.insertedUser.getPhoneNumber()); - assertEquals("test@example.com", repo.insertedUser.getEMail()); + assertEquals(USERNAME, repo.insertedUser.getUsername()); + assertEquals(PHONE, repo.insertedUser.getPhoneNumber()); + assertEquals(EMAIL, repo.insertedUser.getEmail()); } @Test void executeThrowsWhenEmailAlreadyExists() { - RecordingUserRepository repo = new RecordingUserRepository(); repo.emailExists = true; - PasswordHasher hasher = new FakePasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, - () -> userRegister.execute("testuser", "12345678", "secret", "test@example.com") + () -> userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL) ); assertEquals("Email already in use", exception.getMessage()); @@ -60,14 +68,11 @@ void executeThrowsWhenEmailAlreadyExists() { @Test void executeThrowsWhenUsernameAlreadyExists() { - RecordingUserRepository repo = new RecordingUserRepository(); repo.usernameExists = true; - PasswordHasher hasher = new FakePasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, - () -> userRegister.execute("testuser", "12345678", "secret", "test@example.com") + () -> userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL) ); assertEquals("This username is taken", exception.getMessage()); @@ -76,26 +81,21 @@ void executeThrowsWhenUsernameAlreadyExists() { @Test void executeHashesPasswordBeforeSavingUser() { - RecordingUserRepository repo = new RecordingUserRepository(); - RecordingPasswordHasher hasher = new RecordingPasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); + RecordingPasswordHasher recordingHasher = new RecordingPasswordHasher(HASHED_PASSWORD); + userRegister = new UserRegister(recordingHasher, repo); - userRegister.execute("testuser", "12345678", "secret", "test@example.com"); + userRegister.execute(USERNAME, PHONE, PASSWORD, EMAIL); - assertEquals("secret", hasher.lastPasswordInput); + assertEquals(PASSWORD, recordingHasher.lastPasswordInput); assertNotNull(repo.insertedUser); - assertEquals("hashed-password", repo.insertedUser.getPassword()); + assertEquals(HASHED_PASSWORD, repo.insertedUser.getPassword()); } @Test void executePropagatesDomainValidationErrors() { - RecordingUserRepository repo = new RecordingUserRepository(); - PasswordHasher hasher = new FakePasswordHasher("hashed-password"); - UserRegister userRegister = new UserRegister(hasher, repo); - IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, - () -> userRegister.execute("testuser", "1234", "secret", "test@example.com") + () -> userRegister.execute(USERNAME, "1234", PASSWORD, EMAIL) ); assertEquals("Fill in a phonenumber with 8 digits", exception.getMessage()); diff --git a/src/test/java/application/user/UserSignInTest.java b/src/test/java/application/user/UserSignInTest.java new file mode 100644 index 0000000..339c86a --- /dev/null +++ b/src/test/java/application/user/UserSignInTest.java @@ -0,0 +1,213 @@ +package application.user; + +import application.security.PasswordHasher; +import domain.user.User; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import persistence.UserRepository; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +public class UserSignInTest { + + private static final String USERNAME = "testuser"; + private static final String RAW_PASSWORD = "secret"; + private static final String HASHED_PASSWORD = "hashed-secret"; + private static final String EMAIL = "test@example.com"; + private static final String PHONE = "12345678"; + + private User user; + + @BeforeEach + void init() { + user = new User(USERNAME, PHONE, HASHED_PASSWORD, EMAIL); + } + + @Test + void executeReturnsUserWhenCredentialsAreValid() { + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.of(user)); + + UserSignIn userSignIn = new UserSignIn(hasher, repo); + + User result = userSignIn.execute(USERNAME, RAW_PASSWORD); + + assertSame(user, result); + } + + @Test + void executeThrowsWhenLoginDoesNotExist() { + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.empty()); + + UserSignIn userSignIn = new UserSignIn(hasher, repo); + + IllegalArgumentException exception = assertThrows( + IllegalArgumentException.class, + () -> userSignIn.execute("missing-user", RAW_PASSWORD) + ); + + assertEquals("Invalid credentials", exception.getMessage()); + } + + @Test + void executeThrowsWhenPasswordIsWrong() { + PasswordHasher hasher = new FakePasswordHasher("different-hash"); + UserRepository repo = new FakeUserRepository(Optional.of(user)); + + UserSignIn userSignIn = new UserSignIn(hasher, repo); + + IllegalArgumentException exception = assertThrows( + IllegalArgumentException.class, + () -> userSignIn.execute(USERNAME, "wrong-password") + ); + + assertEquals("Invalid password", exception.getMessage()); + } + + @Test + void executeDoesNotHashPasswordWhenLoginDoesNotExist() { + TrackingPasswordHasher hasher = new TrackingPasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.empty()); + + UserSignIn userSignIn = new UserSignIn(hasher, repo); + + assertThrows(IllegalArgumentException.class, + () -> userSignIn.execute("missing-user", RAW_PASSWORD)); + + assertFalse(hasher.wasCalled); + } + + @Test + void executePassesRawPasswordToHasher() { + RecordingPasswordHasher hasher = new RecordingPasswordHasher(HASHED_PASSWORD); + UserRepository repo = new FakeUserRepository(Optional.of(user)); + + UserSignIn userSignIn = new UserSignIn(hasher, repo); + + userSignIn.execute(USERNAME, RAW_PASSWORD); + + assertEquals(RAW_PASSWORD, hasher.lastPassword); + } + + private static class FakePasswordHasher implements PasswordHasher { + private final String hashToReturn; + + private FakePasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + return hashToReturn; + } + } + + private static class FakeUserRepository implements UserRepository { + private final Optional userToReturn; + + private FakeUserRepository(Optional userToReturn) { + this.userToReturn = userToReturn; + } + + @Override + public Optional findByUsername(String username) { + return Optional.empty(); + } + + @Override + public Optional findByEmail(String email) { + return Optional.empty(); + } + + @Override + public Optional findByLogin(String login) { + return userToReturn; + } + + @Override + public boolean existsByEmail(String email) { + return false; + } + + @Override + public boolean existsByUsername(String username) { + return false; + } + + @Override + public void insert(User user) { + } + } + + private static class RecordingUserRepository implements UserRepository { + private final Optional userToReturn; + private String lastLoginUsed; + + private RecordingUserRepository(Optional userToReturn) { + this.userToReturn = userToReturn; + } + + @Override + public Optional findByUsername(String username) { + return Optional.empty(); + } + + @Override + public Optional findByEmail(String email) { + return Optional.empty(); + } + + @Override + public Optional findByLogin(String login) { + lastLoginUsed = login; + return userToReturn; + } + + @Override + public boolean existsByEmail(String email) { + return false; + } + + @Override + public boolean existsByUsername(String username) { + return false; + } + + @Override + public void insert(User user) { + } + } + + private static class TrackingPasswordHasher implements PasswordHasher { + private final String hashToReturn; + private boolean wasCalled; + + private TrackingPasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + wasCalled = true; + return hashToReturn; + } + } + + private static class RecordingPasswordHasher implements PasswordHasher { + private final String hashToReturn; + private String lastPassword; + + private RecordingPasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + lastPassword = password; + return hashToReturn; + } + } +} \ No newline at end of file diff --git a/src/test/java/application/user/UserStatisticsTest.java b/src/test/java/application/user/UserStatisticsTest.java index da904cb..35926af 100644 --- a/src/test/java/application/user/UserStatisticsTest.java +++ b/src/test/java/application/user/UserStatisticsTest.java @@ -1,59 +1,70 @@ package application.user; import domain.user.User; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import persistence.DonationDao; import java.lang.reflect.Field; import java.util.List; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.*; public class UserStatisticsTest { + private static final String USERNAME = "testuser"; + private static final String PHONE = "12345678"; + private static final String PASSWORD = "password"; + private static final String EMAIL = "test@example.com"; + + + private FakeDonationDao fakeDao; + private UserStatistics statistics; + + @BeforeEach void init() throws Exception { + fakeDao = new FakeDonationDao(); + statistics = createStatisticsWithFakeDao(fakeDao); + } + + @Test - void userFavoriteOrganizationsReturnsListFromDonationDao() throws Exception { - FakeDonationDao fakeDao = new FakeDonationDao(); - fakeDao.favoriteOrganizationsToReturn = List.of( + void userFavoriteOrganization_returnsListFromDonationDao() { + List expected = List.of( "Org1 (3 donasjoner)", "Org2 (2 donasjoner)" ); - UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + fakeDao.favoriteOrganizationsToReturn = expected; + User user = createUserWithId(42L); - List result = statistics.userFavoriteOrganizations(user); + List result = statistics.userFavoriteOrganization(user); - assertEquals(List.of("Org1 (3 donasjoner)", "Org2 (2 donasjoner)"), result); - assertEquals(42L, fakeDao.lastUserIdForFavorites); + assertEquals(expected, result); + assertEquals(42L, fakeDao.lastUserIdForFavorite); } @Test - void userDonationsReturnsListFromDonationDao() throws Exception { - FakeDonationDao fakeDao = new FakeDonationDao(); - fakeDao.userDonationsToReturn = List.of( + void userDonations_returnsListFromDonationDao() { + List expected = List.of( "Amount: 100, Date: 2026-04-15, Organization: Org1", "Amount: 50, Date: 2026-04-16, Organization: Org2" ); - UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + fakeDao.userDonationsToReturn = expected; + User user = createUserWithId(7L); List result = statistics.userDonations(user); - assertEquals(List.of( - "Amount: 100, Date: 2026-04-15, Organization: Org1", - "Amount: 50, Date: 2026-04-16, Organization: Org2" - ), result); + assertEquals(expected, result); assertEquals(7L, fakeDao.lastUserIdForDonations); } @Test - void userTotalDonationAmountReturnsValueFromDonationDao() throws Exception { - FakeDonationDao fakeDao = new FakeDonationDao(); + void userTotalDonationAmount_returnsValueFromDonationDao() { fakeDao.totalDonationAmountToReturn = "250.00"; - UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); User user = createUserWithId(15L); String result = statistics.userTotalDonationAmount(user); @@ -63,11 +74,9 @@ void userTotalDonationAmountReturnsValueFromDonationDao() throws Exception { } @Test - void getTotalDonationsMadeReturnsValueFromDonationDao() throws Exception { - FakeDonationDao fakeDao = new FakeDonationDao(); + void getTotalDonationsMade_returnsValueFromDonationDao() { fakeDao.totalDonationsMadeToReturn = "5"; - UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); User user = createUserWithId(99L); String result = statistics.getTotalDonationsMade(user); @@ -76,7 +85,44 @@ void getTotalDonationsMadeReturnsValueFromDonationDao() throws Exception { assertEquals(99L, fakeDao.lastUserIdForTotalCount); } + @Test + void userFavoriteOrganization_withNullUser_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> statistics.userFavoriteOrganization(null)); + } + + @Test + void userDonations_withNullUser_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> statistics.userDonations(null)); + } + @Test + void userTotalDonationAmount_withNullUser_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> statistics.userTotalDonationAmount(null)); + } + + @Test + void getTotalDonationsMade_withNullUser_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> statistics.getTotalDonationsMade(null)); + } + + @Test + void userFavoriteOrganization_withUserNullId_throwsNullPointerException() { + User user = new User(USERNAME, PHONE, PASSWORD, EMAIL); + + assertThrows(NullPointerException.class, () -> statistics.userFavoriteOrganization(user)); + } + + @Test + void constructor_initializesDonationDao() throws Exception { + Field field = UserStatistics.class.getDeclaredField("donationDao"); + field.setAccessible(true); + + UserStatistics newStatistics = new UserStatistics(); + Object dao = field.get(newStatistics); + + assertNotNull(dao); + assertEquals(DonationDao.class, dao.getClass()); + } private UserStatistics createStatisticsWithFakeDao(FakeDonationDao fakeDao) throws Exception { UserStatistics statistics = new UserStatistics(); @@ -89,7 +135,7 @@ private UserStatistics createStatisticsWithFakeDao(FakeDonationDao fakeDao) thro } private User createUserWithId(long id) { - User user = new User("testuser", "12345678", "password", "test@example.com"); + User user = new User(USERNAME, PHONE, PASSWORD, EMAIL); user.setId(id); return user; } @@ -100,14 +146,14 @@ private static class FakeDonationDao extends DonationDao { private String totalDonationAmountToReturn = "0"; private String totalDonationsMadeToReturn = "0"; - private long lastUserIdForFavorites; + private long lastUserIdForFavorite; private long lastUserIdForDonations; private long lastUserIdForTotalAmount; private long lastUserIdForTotalCount; @Override - public List getFavoriteOrganizations(long userId) { - lastUserIdForFavorites = userId; + public List getFavoriteOrganization(long userId) { + lastUserIdForFavorite = userId; return favoriteOrganizationsToReturn; } diff --git a/src/test/java/domain/DonationTest.java b/src/test/java/domain/DonationTest.java index ea73049..5e13f2a 100644 --- a/src/test/java/domain/DonationTest.java +++ b/src/test/java/domain/DonationTest.java @@ -1,6 +1,5 @@ package domain; -import domain.donation.Cause; import domain.donation.Donation; import domain.organization.Organization; import domain.user.User; @@ -17,104 +16,162 @@ class DonationTest { - //User Variables - private final String testUserName = "testUser"; - private final String testPhoneNumber = "90909090"; - private final String testEmail = "test@email.com"; - private final String testPassword = "password"; - - //Organization Variables - private final String testName = "Name"; - private final String testOrgNr = "123456789"; - private final Cause testCause = Cause.HEALTH; - private final String testDescription = "Description"; - private final String testContactEmail = "test@mail.com"; - private final String testWebsite = "https://test.com"; - private final boolean testVerified = true; - - //Donation Variables - private Long testID = 123L; - private BigDecimal testAmount = new BigDecimal("1500"); - private LocalDateTime testDateTime = LocalDateTime.of(2026, 3, 5, 8, 30, 0); + //Test Variables + private static final BigDecimal VALID_AMOUNT = new BigDecimal("1500"); + private static final BigDecimal SMALL_VALID_AMOUNT = new BigDecimal("0.01"); + private User testUser; private Organization testOrganization; @BeforeEach public void init() { - testUser = new User(testUserName, testPhoneNumber, testPassword, testEmail); - testOrganization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); + testUser = new User("testUser", "90909090", "password", "test@mail.com"); + testOrganization = new Organization(); } @Test - public void DonationTestPositive(){ - Donation donation = new Donation(testAmount, testUser, testOrganization); + public void constructor_withValidInput_createsDonation() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); } @Test - public void DonationTestUserNull(){ + public void constructor_withNullUser_throwsNullPointerException() { testUser = null; NullPointerException Exception = assertThrows(NullPointerException.class, - () -> new Donation (testAmount, testUser, testOrganization)); + () -> new Donation(VALID_AMOUNT, testUser, testOrganization)); assertEquals("User cannot be null", Exception.getMessage()); } @Test - public void DonationOrganizationNull(){ + public void constructor_withNullOrganization_throwsNullPointerException() { testOrganization = null; NullPointerException Exception = assertThrows(NullPointerException.class, - () -> new Donation (testAmount, testUser, testOrganization)); + () -> new Donation(VALID_AMOUNT, testUser, testOrganization)); assertEquals("Organization cannot be null", Exception.getMessage()); } @Test - public void DonationTestAmountNegative(){ - testAmount = new BigDecimal("-23"); + public void constructor_withPositiveDecimalAmount_setsFieldsCorrectly() { + Donation donation = new Donation(SMALL_VALID_AMOUNT, testUser, testOrganization); + + assertEquals(SMALL_VALID_AMOUNT, donation.getAmount()); + assertEquals(testUser, donation.getUser()); + assertEquals(testOrganization, donation.getOrganization()); + } + + @Test + public void constructor_withNegativeAmount_throwsIllegalArgumentException() { IllegalArgumentException Exception = assertThrows(IllegalArgumentException.class, - () -> new Donation (testAmount, testUser, testOrganization)); + () -> new Donation(new BigDecimal("-23"), testUser, testOrganization)); assertEquals("Amount must be greater than 0", Exception.getMessage()); } - //Getter tests - /* id is never set, getter makes a NullPointerException @Test - public void DonationTestIdGet(){ - Donation donation = new Donation(testAmount, testUser, testOrganization); - assertEquals(0L, donation.getId()); + public void constructor_withZeroAmount_throwsIllegalArgumentException() { + IllegalArgumentException Exception = assertThrows(IllegalArgumentException.class, + () -> new Donation(new BigDecimal("0"), testUser, testOrganization)); + assertEquals("Amount must be greater than 0", Exception.getMessage()); } - */ @Test - public void DonationTestAmountGet(){ - Donation donation = new Donation(testAmount, testUser, testOrganization); - assertEquals(testAmount, donation.getAmount()); + public void constructor_withNullAmount_throwsNullPointerException() { + NullPointerException Exception = assertThrows(NullPointerException.class, + () -> new Donation(null, testUser, testOrganization)); + assertEquals("Amount cannot be null", Exception.getMessage()); } @Test - public void DonationTestDateTimeGet(){ + public void getAmount_returnsCorrectValue() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + assertEquals(VALID_AMOUNT, donation.getAmount()); + + } + + @Test + public void getDateTime_returnsCurrentTime() { LocalDateTime now = LocalDateTime.now(); - Donation donation = new Donation(testAmount, testUser, testOrganization); + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); assertTrue(Duration.between(now, donation.getDateTime()).abs().toMillis() < 1000); } @Test - public void DonationTestUserGet(){ - Donation donation = new Donation(testAmount, testUser, testOrganization); + public void getUser_returnsCorrectUser() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); assertEquals(testUser, donation.getUser()); } @Test - public void DonationTestOrganizationGet(){ - Donation donation = new Donation(testAmount, testUser, testOrganization); + public void getOrganization_returnsCorrectOrganization() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); assertEquals(testOrganization, donation.getOrganization()); } -} \ No newline at end of file + + @Test + public void setId_withValidPositiveId_setsIdSuccessfully() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + donation.setId(1L); + + assertEquals(1L, donation.getId()); + + } + + @Test + public void setId_withInvalidNullId_throwsIllegalArgumentException() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, + () -> donation.setId(null)); + + assertEquals("ID must be positive", exception.getMessage()); + } + + @Test + public void setId_withInvalidNegativeId_throwsIllegalArgumentException() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, + () -> donation.setId(-1L)); + + assertEquals("ID must be positive", exception.getMessage()); + } + + @Test + public void setId_withInvalidZeroId_throwsIllegalArgumentException() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, + () -> donation.setId(0L)); + + assertEquals("ID must be positive", exception.getMessage()); + } + + @Test + public void setId_whenCalledTwice_throwsIllegalStateException() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + donation.setId(1L); + + IllegalStateException exception = assertThrows(IllegalStateException.class, + () -> donation.setId(2L)); + + assertEquals("ID is already set", exception.getMessage()); + } + + @Test + public void getId_beforeSetId_throwsNullPointerException() { + Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + + assertThrows(NullPointerException.class, donation::getId); + } +} diff --git a/src/test/java/domain/OrganizationTest.java b/src/test/java/domain/OrganizationTest.java index 47c8024..ebf654a 100644 --- a/src/test/java/domain/OrganizationTest.java +++ b/src/test/java/domain/OrganizationTest.java @@ -1,207 +1,120 @@ package domain; +import com.fasterxml.jackson.databind.ObjectMapper; import domain.donation.Cause; import domain.organization.Organization; import domain.user.User; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.*; class OrganizationTest { - private String testName = "Name"; - private String testOrgNr = "123456789"; - private Cause testCause = Cause.HEALTH; - private String testDescription = "Description"; - private String testContactEmail = "test@mail.com"; - private String testWebsite = "https://test.com"; - private boolean testVerified = true; - - //Positive tests - @Test - public void organizationTestPositive(){ - Organization organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - } - //Negative tests - @Test - public void organizationTestNameBlank(){ - testName = ""; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization("", testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - - assertEquals("Name cannot be null or blank", exception.getMessage()); - } + private final ObjectMapper mapper = new ObjectMapper(); @Test - public void organizationTestNameNull(){ - testName = null; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + void constructor_setsDefaultEmptyValues() { + Organization org = new Organization(); - assertEquals("Name cannot be null or blank", exception.getMessage()); + assertNull(org.getOrgNumber()); + assertNull(org.getName()); + assertNull(org.getUrl()); + assertNull(org.getStatus()); + assertFalse(org.isPreApproved()); } @Test - public void organizationTestOrgNrNull(){ - testOrgNr = null; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + void setters_updateAllFields() { + Organization org = new Organization(); - assertEquals("Organization number must be 9 digits", exception.getMessage()); - } + org.setOrgNumber("123456789"); + org.setName("TestOrg"); + org.setUrl("https://testOrg.com"); + org.setStatus("ACTIVE"); + org.setPreApproved(true); - @Test - public void organizationTestOrgNrLetters(){ - testOrgNr = "12345678a"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - - assertEquals("Organization number must be 9 digits", exception.getMessage()); + assertEquals("123456789", org.getOrgNumber()); + assertEquals("TestOrg", org.getName()); + assertEquals("https://testOrg.com", org.getUrl()); + assertEquals("ACTIVE", org.getStatus()); + assertTrue(org.isPreApproved()); } @Test - public void organizationTestOrgNrShort(){ - testOrgNr = "12345"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + void deserializeJson_mapsAllFieldsCorrectly() throws Exception { + String json = """ + { + "org_number": "123456789", + "name": "TestOrg", + "status": "ACTIVE", + "url": "https://testOrg.com", + "is_pre_approved": true + } + """; - assertEquals("Organization number must be 9 digits", exception.getMessage()); - } - /* Mangler exception for når email er null - @Test - public void organizationTestContactEmailNull(){ - testContactEmail = null; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - } - */ + Organization org = mapper.readValue(json, Organization.class); - @Test - public void organizationTestContactEmailTrim(){ - testContactEmail = "test@mail.com "; - Organization organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); + assertEquals("123456789", org.getOrgNumber()); + assertEquals("TestOrg", org.getName()); + assertEquals("ACTIVE", org.getStatus()); + assertEquals("https://testOrg.com", org.getUrl()); + assertTrue(org.isPreApproved()); } @Test - public void organizationTestContactEmailBlank(){ - testContactEmail = ""; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + void deserializeJson_ignoresUnknownFields() throws Exception { + String json = """ + { + "org_number": "123456789", + "name": "TestOrg", + "status": "ACTIVE", + "url": "https://testOrg.com", + "is_pre_approved": true, + "unknown_field": "Ignore this" + } + """; - assertEquals("Email cannot be blank", exception.getMessage()); - } + Organization org = mapper.readValue(json, Organization.class); - @Test - public void organizationTestContactEmailMissingAt(){ - testContactEmail = "test.com"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - - assertEquals("Invalid email format", exception.getMessage()); - } - - @Test - public void organizationTestContactEmailDoubleAt(){ - testContactEmail = "test@@mail.com"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - - assertEquals("Invalid email format", exception.getMessage()); + assertEquals("123456789", org.getOrgNumber()); + assertEquals("TestOrg", org.getName()); + assertEquals("ACTIVE", org.getStatus()); + assertEquals("https://testOrg.com", org.getUrl()); + assertTrue(org.isPreApproved()); } @Test - public void organizationTestContactEmailMisplacedAt(){ - testContactEmail = "@testmail.com"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + void deserializeJson_usesDefaultValuesForMissingFields() throws Exception { + String json = """ + { + "org_number": "123456789", + "name": "TestOrg", + "status": "ACTIVE", + "url": "https://testOrg.com" + } + """; - assertEquals("Invalid email format", exception.getMessage()); - } - @Test - public void organizationTestContactEmailMissingDot(){ - testContactEmail = "test@mailcom"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + Organization org = mapper.readValue(json, Organization.class); - assertEquals("Invalid email format", exception.getMessage()); + assertEquals("123456789", org.getOrgNumber()); + assertEquals("TestOrg", org.getName()); + assertEquals("ACTIVE", org.getStatus()); + assertEquals("https://testOrg.com", org.getUrl()); + assertFalse(org.isPreApproved()); } @Test - public void organizationTestWebsiteMissingHttps(){ - testWebsite = "test.com"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - - assertEquals("Website must start with http:// or https://", exception.getMessage()); - } + void setPreApproved_togglesValue() { + Organization org = new Organization(); - /* Mangler exception når url mangler domain extension (.com f.eks) - @Test - public void organizationTestWebsiteMissingDot(){ - testWebsite = "https://testcom"; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); + org.setPreApproved(true); + assertTrue(org.isPreApproved()); - assertEquals("Website must start with http:// or https://", exception.getMessage()); + org.setPreApproved(false); + assertFalse(org.isPreApproved()); } - */ - /* Mangler exception når website er null - @Test - public void organizationTestWebsiteMissingDot(){ - testWebsite = null; - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified)); - assertEquals("Website must start with http:// or https://", exception.getMessage()); - } - */ - - - - //Getter tests - @Test - public void organizationTestNameGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testName, Organization.getName()); - } - - @Test - public void organizationTestOrgNrGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testOrgNr, Organization.getOrgNr()); - } - - @Test - public void organizationTestCauseGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testCause, Organization.getCause()); - } - - @Test - public void organizationDescriptionGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testDescription, Organization.getDescription()); - } - - @Test - public void organizationTestContactEmailGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testContactEmail, Organization.getContactEmail()); - } - - @Test - public void organizationTestWebsiteGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testWebsite, Organization.getWebsite()); - } - - @Test - public void organizationTestIsVerifiedGet(){ - Organization Organization = new Organization(testName, testOrgNr, testCause, testDescription, testContactEmail, testWebsite, testVerified); - assertEquals(testVerified, Organization.isVerified()); - } -} \ No newline at end of file +} diff --git a/src/test/java/domain/UserTest.java b/src/test/java/domain/UserTest.java index b1c8f14..0d149d9 100644 --- a/src/test/java/domain/UserTest.java +++ b/src/test/java/domain/UserTest.java @@ -2,136 +2,133 @@ import domain.user.User; import org.junit.jupiter.api.Test; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; + +import static org.junit.jupiter.api.Assertions.*; class UserTest { - private String testUserName = "testUser"; - private String testPhoneNumber = "90909090"; - private String testEmail = "test@email.com"; - private final String testPassword = "password"; + private static final String USERNAME = "testUser"; + private static final String PHONE = "90909090"; + private static final String EMAIL = "test@email.com"; + private static final String PASSWORD = "password"; //Positive tests @Test - public void userTestPositive(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); + public void constructor_withValidInput_createsUser(){ + User user = createUser(); } //Negative tests @Test - public void userTestUserNameBlank(){ - testUserName = ""; + public void constructor_withBlankUsername_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User("", PHONE, PASSWORD, EMAIL)); assertEquals("Username has to be filled in", exception.getMessage()); } @Test - public void userTestUserNameNull(){ - testUserName = null; + public void constructor_withNullUsername_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(null, PHONE, PASSWORD, EMAIL)); assertEquals("Username has to be filled in", exception.getMessage()); } @Test - public void userTestPhoneNumberBlank(){ - testPhoneNumber = ""; + public void constructor_withBlankPhoneNumber_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(USERNAME, "", PASSWORD, EMAIL)); assertEquals("Phonenumber has to be filled in", exception.getMessage()); } @Test - public void userTestPhoneNumberNull(){ - testPhoneNumber = null; + public void constructor_withNullPhoneNumber_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(USERNAME, null, PASSWORD, EMAIL)); assertEquals("Phonenumber has to be filled in", exception.getMessage()); } @Test - public void userTestPhoneNumberShort() { - testPhoneNumber = "909090"; + public void constructor_withShortPhoneNumber_throwsIllegalArgumentException() { IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(USERNAME, "909090", PASSWORD, EMAIL)); assertEquals("Fill in a phonenumber with 8 digits", exception.getMessage()); } @Test - public void userTestEmailBlank(){ - testEmail = ""; + public void constructor_withBlankEmail_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(USERNAME, PHONE, PASSWORD, "")); - assertEquals("E-mail has to be filled in", exception.getMessage()); + assertEquals("Invalid email address: ", exception.getMessage()); } @Test - public void userTestEmailNull(){ - testEmail = null; + public void constructor_withNullEmail_throwsIllegalArgumentException(){ IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> new User(testUserName, testPhoneNumber, testPassword, testEmail)); + () -> new User(USERNAME, PHONE, PASSWORD, null)); - assertEquals("E-mail has to be filled in", exception.getMessage()); + assertEquals("Invalid email address: null", exception.getMessage()); } //Getter tests @Test - public void userTestUserNameGet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - assertEquals(User.getUsername(), testUserName); + public void getUsername_returnsUsername(){ + User user = createUser(); + assertEquals(USERNAME, user.getUsername()); } @Test - public void userTestPhoneNumberGet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - assertEquals(User.getPhoneNumber(), testPhoneNumber); + public void getPhoneNumber_returnsPhoneNumber(){ + User user = createUser(); + assertEquals(PHONE, user.getPhoneNumber()); } @Test - public void userTestEmailGet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - assertEquals(User.getEMail(), testEmail); + public void getEmail_returnsEmail(){ + User user = createUser(); + assertEquals(EMAIL, user.getEmail()); } @Test - public void userTestPasswordGet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - assertEquals(User.getPassword(), testPassword); + public void getPassword_returnsPassword(){ + User user = createUser(); + assertEquals(PASSWORD, user.getPassword()); } //Setter tests @Test - public void userTestPasswordSet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - String newPassword = "NewPassoword"; - User.setPassword(newPassword); - assertEquals(newPassword, User.getPassword()); + public void setPassword_updatesPassword(){ + User user = createUser(); + String newPassword = "newPassword"; + user.setPassword(newPassword); + assertEquals(newPassword, user.getPassword()); } @Test - public void userTestUserNameSet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); + public void setUsername_updatesUsername(){ + User user = createUser(); String newUserName = "NewUsername"; - User.setUsername(newUserName); - assertEquals(newUserName, User.getUsername()); + user.setUsername(newUserName); + assertEquals(newUserName, user.getUsername()); } @Test - public void userTestPhoneNumberSet(){ - User User = new User(testUserName, testPhoneNumber, testPassword, testEmail); - String newPhoneNumber = "123456asdsad7"; //Trenger input validering - User.setPhonenumber(newPhoneNumber); - assertEquals(newPhoneNumber, User.getPhoneNumber()); + public void setPhoneNumber_updatesPhoneNumber(){ + User user = createUser(); + String newPhoneNumber = "123456asdsad7"; + user.setPhonenumber(newPhoneNumber); + assertEquals(newPhoneNumber, user.getPhoneNumber()); + } + + private User createUser() { + return new User(USERNAME, PHONE, PASSWORD, EMAIL); } -} \ No newline at end of file +} From f7aa81a9925f289233d6d8fe31ec04ce848b98f1 Mon Sep 17 00:00:00 2001 From: haavajor Date: Thu, 23 Apr 2026 02:45:56 +0200 Subject: [PATCH 2/3] Refactored unit tests, increased coverage, renamed unit test method names to be more consistent and accurate for the test being done. Reduced number of warnings --- .../java/application/user/UserLoginTest.java | 77 ++++++------ .../application/user/UserRegisterTest.java | 3 +- .../java/application/user/UserSignInTest.java | 114 +++++------------- .../application/user/UserStatisticsTest.java | 4 + src/test/java/domain/OrganizationTest.java | 2 - src/test/java/domain/UserTest.java | 1 + 6 files changed, 73 insertions(+), 128 deletions(-) diff --git a/src/test/java/application/user/UserLoginTest.java b/src/test/java/application/user/UserLoginTest.java index bce7003..c88fa85 100644 --- a/src/test/java/application/user/UserLoginTest.java +++ b/src/test/java/application/user/UserLoginTest.java @@ -12,7 +12,7 @@ public class UserLoginTest { - private static final String USERNAME = "testuser"; + private static final String USERNAME = "testUser"; private static final String RAW_PASSWORD = "secret"; private static final String HASHED_PASSWORD = "hashed-secret"; private static final String EMAIL = "test@example.com"; @@ -69,14 +69,14 @@ void executeThrowsWhenPasswordIsWrong() { @Test void executeUsesNormalizedLoginBeforeLookup() { - RecordingUserRepository repo = new RecordingUserRepository(Optional.of(user)); + RecordingUserRepository repo = new RecordingUserRepository(user); PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); UserLogin userLogin = new UserLogin(hasher, repo); - userLogin.execute(" TestUser ", RAW_PASSWORD); + userLogin.execute(" testUser ", RAW_PASSWORD); - assertEquals(USERNAME, repo.lastLoginUsed); + assertEquals("testuser", repo.lastLoginUsed); } @Test @@ -104,60 +104,51 @@ void executePassesRawPasswordToHasher() { assertEquals(RAW_PASSWORD, hasher.lastPassword); } - private static class FakePasswordHasher implements PasswordHasher{ - private final String hashToReturn; - private FakePasswordHasher(String hashToReturn) { - this.hashToReturn = hashToReturn; - } + private record FakePasswordHasher(String hashToReturn) implements PasswordHasher { @Override - public String hash(String password) { - return hashToReturn; + public String hash(String password) { + return hashToReturn; + } } - } - - private static class FakeUserRepository implements UserRepository { - private final Optional userToReturn; - private FakeUserRepository(Optional userToReturn) { - this.userToReturn = userToReturn; - } + private record FakeUserRepository(Optional userToReturn) implements UserRepository { @Override - public Optional findByUsername(String username){ - return Optional.empty(); - } + public Optional findByUsername(String username) { + return Optional.empty(); + } - @Override - public Optional findByEmail(String email){ - return Optional.empty(); - } + @Override + public Optional findByEmail(String email) { + return Optional.empty(); + } - @Override - public Optional findByLogin(String login) { - return userToReturn; - } + @Override + public Optional findByLogin(String login) { + return userToReturn; + } - @Override - public boolean existsByEmail(String email) { - return false; - } + @Override + public boolean existsByEmail(String email) { + return false; + } - @Override - public boolean existsByUsername(String username) { - return false; - } + @Override + public boolean existsByUsername(String username) { + return false; + } - @Override - public void insert(User user) { + @Override + public void insert(User user) { + } } - } private static class RecordingUserRepository implements UserRepository { - private final Optional userToReturn; + private final User userToReturn; private String lastLoginUsed; - private RecordingUserRepository(Optional userToReturn) { + private RecordingUserRepository(User userToReturn) { this.userToReturn = userToReturn; } @@ -174,7 +165,7 @@ public Optional findByEmail(String email) { @Override public Optional findByLogin(String login) { lastLoginUsed = login; - return userToReturn; + return Optional.ofNullable(userToReturn); } @Override diff --git a/src/test/java/application/user/UserRegisterTest.java b/src/test/java/application/user/UserRegisterTest.java index aae8e83..2c60ba3 100644 --- a/src/test/java/application/user/UserRegisterTest.java +++ b/src/test/java/application/user/UserRegisterTest.java @@ -20,13 +20,12 @@ public class UserRegisterTest { private static final String HASHED_PASSWORD = "hashed-password"; private RecordingUserRepository repo; - private PasswordHasher hasher; private UserRegister userRegister; @BeforeEach void setUp() { repo = new RecordingUserRepository(); - hasher = new FakePasswordHasher(HASHED_PASSWORD); + PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); userRegister = new UserRegister(hasher, repo); } diff --git a/src/test/java/application/user/UserSignInTest.java b/src/test/java/application/user/UserSignInTest.java index 339c86a..0af290c 100644 --- a/src/test/java/application/user/UserSignInTest.java +++ b/src/test/java/application/user/UserSignInTest.java @@ -12,7 +12,7 @@ public class UserSignInTest { - private static final String USERNAME = "testuser"; + private static final String USERNAME = "testUser"; private static final String RAW_PASSWORD = "secret"; private static final String HASHED_PASSWORD = "hashed-secret"; private static final String EMAIL = "test@example.com"; @@ -28,7 +28,7 @@ void init() { @Test void executeReturnsUserWhenCredentialsAreValid() { PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); - UserRepository repo = new FakeUserRepository(Optional.of(user)); + UserRepository repo = new FakeUserRepository(user); UserSignIn userSignIn = new UserSignIn(hasher, repo); @@ -40,7 +40,7 @@ void executeReturnsUserWhenCredentialsAreValid() { @Test void executeThrowsWhenLoginDoesNotExist() { PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD); - UserRepository repo = new FakeUserRepository(Optional.empty()); + UserRepository repo = new FakeUserRepository(null); UserSignIn userSignIn = new UserSignIn(hasher, repo); @@ -55,7 +55,7 @@ void executeThrowsWhenLoginDoesNotExist() { @Test void executeThrowsWhenPasswordIsWrong() { PasswordHasher hasher = new FakePasswordHasher("different-hash"); - UserRepository repo = new FakeUserRepository(Optional.of(user)); + UserRepository repo = new FakeUserRepository(user); UserSignIn userSignIn = new UserSignIn(hasher, repo); @@ -70,7 +70,7 @@ void executeThrowsWhenPasswordIsWrong() { @Test void executeDoesNotHashPasswordWhenLoginDoesNotExist() { TrackingPasswordHasher hasher = new TrackingPasswordHasher(HASHED_PASSWORD); - UserRepository repo = new FakeUserRepository(Optional.empty()); + UserRepository repo = new FakeUserRepository(null); UserSignIn userSignIn = new UserSignIn(hasher, repo); @@ -83,7 +83,7 @@ void executeDoesNotHashPasswordWhenLoginDoesNotExist() { @Test void executePassesRawPasswordToHasher() { RecordingPasswordHasher hasher = new RecordingPasswordHasher(HASHED_PASSWORD); - UserRepository repo = new FakeUserRepository(Optional.of(user)); + UserRepository repo = new FakeUserRepository(user); UserSignIn userSignIn = new UserSignIn(hasher, repo); @@ -92,94 +92,46 @@ void executePassesRawPasswordToHasher() { assertEquals(RAW_PASSWORD, hasher.lastPassword); } - private static class FakePasswordHasher implements PasswordHasher { - private final String hashToReturn; - - private FakePasswordHasher(String hashToReturn) { - this.hashToReturn = hashToReturn; - } + private record FakePasswordHasher(String hashToReturn) implements PasswordHasher { @Override - public String hash(String password) { - return hashToReturn; + public String hash(String password) { + return hashToReturn; + } } - } - - private static class FakeUserRepository implements UserRepository { - private final Optional userToReturn; - private FakeUserRepository(Optional userToReturn) { - this.userToReturn = userToReturn; - } + private record FakeUserRepository(User userToReturn) implements UserRepository { @Override - public Optional findByUsername(String username) { - return Optional.empty(); - } + public Optional findByUsername(String username) { + return Optional.empty(); + } - @Override - public Optional findByEmail(String email) { - return Optional.empty(); - } + @Override + public Optional findByEmail(String email) { + return Optional.empty(); + } - @Override - public Optional findByLogin(String login) { - return userToReturn; - } + @Override + public Optional findByLogin(String login) { + return Optional.ofNullable(userToReturn); + } - @Override - public boolean existsByEmail(String email) { - return false; - } + @Override + public boolean existsByEmail(String email) { + return false; + } - @Override - public boolean existsByUsername(String username) { - return false; - } + @Override + public boolean existsByUsername(String username) { + return false; + } - @Override - public void insert(User user) { + @Override + public void insert(User user) { + } } - } - - private static class RecordingUserRepository implements UserRepository { - private final Optional userToReturn; - private String lastLoginUsed; - private RecordingUserRepository(Optional userToReturn) { - this.userToReturn = userToReturn; - } - - @Override - public Optional findByUsername(String username) { - return Optional.empty(); - } - - @Override - public Optional findByEmail(String email) { - return Optional.empty(); - } - - @Override - public Optional findByLogin(String login) { - lastLoginUsed = login; - return userToReturn; - } - - @Override - public boolean existsByEmail(String email) { - return false; - } - - @Override - public boolean existsByUsername(String username) { - return false; - } - - @Override - public void insert(User user) { - } - } private static class TrackingPasswordHasher implements PasswordHasher { private final String hashToReturn; diff --git a/src/test/java/application/user/UserStatisticsTest.java b/src/test/java/application/user/UserStatisticsTest.java index 35926af..fdadd48 100644 --- a/src/test/java/application/user/UserStatisticsTest.java +++ b/src/test/java/application/user/UserStatisticsTest.java @@ -87,21 +87,25 @@ void getTotalDonationsMade_returnsValueFromDonationDao() { @Test void userFavoriteOrganization_withNullUser_throwsNullPointerException() { + //noinspection DataFlowIssue assertThrows(NullPointerException.class, () -> statistics.userFavoriteOrganization(null)); } @Test void userDonations_withNullUser_throwsNullPointerException() { + //noinspection DataFlowIssue assertThrows(NullPointerException.class, () -> statistics.userDonations(null)); } @Test void userTotalDonationAmount_withNullUser_throwsNullPointerException() { + //noinspection DataFlowIssue assertThrows(NullPointerException.class, () -> statistics.userTotalDonationAmount(null)); } @Test void getTotalDonationsMade_withNullUser_throwsNullPointerException() { + //noinspection DataFlowIssue assertThrows(NullPointerException.class, () -> statistics.getTotalDonationsMade(null)); } diff --git a/src/test/java/domain/OrganizationTest.java b/src/test/java/domain/OrganizationTest.java index ebf654a..8ac057b 100644 --- a/src/test/java/domain/OrganizationTest.java +++ b/src/test/java/domain/OrganizationTest.java @@ -1,9 +1,7 @@ package domain; import com.fasterxml.jackson.databind.ObjectMapper; -import domain.donation.Cause; import domain.organization.Organization; -import domain.user.User; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; diff --git a/src/test/java/domain/UserTest.java b/src/test/java/domain/UserTest.java index 0d149d9..be15c9c 100644 --- a/src/test/java/domain/UserTest.java +++ b/src/test/java/domain/UserTest.java @@ -16,6 +16,7 @@ class UserTest { @Test public void constructor_withValidInput_createsUser(){ User user = createUser(); + assertNotNull(user); } //Negative tests From c625850da7810bc05a64620b4baf7ec14003ba2a Mon Sep 17 00:00:00 2001 From: haavajor Date: Thu, 23 Apr 2026 02:48:31 +0200 Subject: [PATCH 3/3] Refactored unit tests, increased coverage, renamed unit test method names to be more consistent and accurate for the test being done. Reduced number of warnings --- src/test/java/domain/DonationTest.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/test/java/domain/DonationTest.java b/src/test/java/domain/DonationTest.java index 5e13f2a..710df81 100644 --- a/src/test/java/domain/DonationTest.java +++ b/src/test/java/domain/DonationTest.java @@ -10,9 +10,8 @@ import java.time.Duration; import java.time.LocalDateTime; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.*; + class DonationTest { @@ -33,6 +32,7 @@ public void init() { @Test public void constructor_withValidInput_createsDonation() { Donation donation = new Donation(VALID_AMOUNT, testUser, testOrganization); + assertNotNull(donation); } @Test