From 621da6c8e1bdb1bd938ffeda4f827854f83b6b16 Mon Sep 17 00:00:00 2001 From: haavajor Date: Wed, 15 Apr 2026 09:45:45 +0200 Subject: [PATCH] Unit tests --- src/main/java/application/user/UserLogin.java | 2 +- .../java/application/user/UserLoginTest.java | 162 +++++++++++++++++ .../application/user/UserRegisterTest.java | 170 ++++++++++++++++++ .../application/user/UserStatisticsTest.java | 132 ++++++++++++++ .../security/Sha256PasswordHasherTest.java | 26 +++ 5 files changed, 491 insertions(+), 1 deletion(-) create mode 100644 src/test/java/application/user/UserLoginTest.java create mode 100644 src/test/java/application/user/UserRegisterTest.java create mode 100644 src/test/java/application/user/UserStatisticsTest.java create mode 100644 src/test/java/integration/security/Sha256PasswordHasherTest.java diff --git a/src/main/java/application/user/UserLogin.java b/src/main/java/application/user/UserLogin.java index e116498..50940ac 100644 --- a/src/main/java/application/user/UserLogin.java +++ b/src/main/java/application/user/UserLogin.java @@ -16,7 +16,7 @@ public UserLogin(PasswordHasher hasher, UserRepository repo) { public User execute(String login, String password) { // normalize (trim etc.) - login.trim().toLowerCase(); + login = login.trim().toLowerCase(); User user = repo.findByLogin(login) .orElseThrow(() -> new IllegalArgumentException("Invalid credentials")); diff --git a/src/test/java/application/user/UserLoginTest.java b/src/test/java/application/user/UserLoginTest.java new file mode 100644 index 0000000..4bd8312 --- /dev/null +++ b/src/test/java/application/user/UserLoginTest.java @@ -0,0 +1,162 @@ +package application.user; + +import application.security.PasswordHasher; +import domain.user.User; +import org.junit.jupiter.api.Test; +import persistence.UserRepository; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +public class UserLoginTest { + + @Test + void executeReturnsUserWhenCredentialsAreValid() { + User user = new User("testuser", "12345678", "hashed-secret", "test@example.com"); + PasswordHasher hasher = new FakePasswordHasher("hashed-secret"); + UserRepository repo = new FakeUserRepository(Optional.of(user)); + + UserLogin userLogin = new UserLogin(hasher, repo); + + User result = userLogin.execute("testuser", "secret"); + + assertSame(user, result); + + } + + @Test + void executeThrowsWhenLoginDoesNotExist() { + PasswordHasher hasher = new FakePasswordHasher("hashed-secret"); + UserRepository repo = new FakeUserRepository(Optional.empty()); + + UserLogin userLogin = new UserLogin(hasher, repo); + + IllegalArgumentException exception = assertThrows( + IllegalArgumentException.class, + () -> userLogin.execute("missing-user", "secret") + ); + + assertEquals("Invalid credentials", exception.getMessage()); + } + + @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)); + + UserLogin userLogin = new UserLogin(hasher, repo); + + IllegalArgumentException exception = assertThrows( + IllegalArgumentException.class, + () -> userLogin.execute("testuser", "wrong-password") + ); + + assertEquals("Invalid password", exception.getMessage()); + } + + @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"); + + UserLogin userLogin = new UserLogin(hasher, repo); + + userLogin.execute(" TestUser ", "secret"); + + assertEquals("testuser", repo.lastLoginUsed); + } + + 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) { + } + } + + +} + diff --git a/src/test/java/application/user/UserRegisterTest.java b/src/test/java/application/user/UserRegisterTest.java new file mode 100644 index 0000000..c5296cd --- /dev/null +++ b/src/test/java/application/user/UserRegisterTest.java @@ -0,0 +1,170 @@ +package application.user; + +import application.security.PasswordHasher; +import domain.user.User; +import org.junit.jupiter.api.Test; +import persistence.UserRepository; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.*; + +public class UserRegisterTest { + + @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"); + + 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()); + } + + + @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 "); + + assertNotNull(repo.insertedUser); + assertEquals("testuser", repo.insertedUser.getUsername()); + assertEquals("12345678", repo.insertedUser.getPhoneNumber()); + assertEquals("test@example.com", 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") + ); + + assertEquals("Email already in use", exception.getMessage()); + assertNull(repo.insertedUser); + } + + @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") + ); + + assertEquals("This username is taken", exception.getMessage()); + assertNull(repo.insertedUser); + } + + @Test + void executeHashesPasswordBeforeSavingUser() { + RecordingUserRepository repo = new RecordingUserRepository(); + RecordingPasswordHasher hasher = new RecordingPasswordHasher("hashed-password"); + UserRegister userRegister = new UserRegister(hasher, repo); + + userRegister.execute("testuser", "12345678", "secret", "test@example.com"); + + assertEquals("secret", hasher.lastPasswordInput); + assertNotNull(repo.insertedUser); + 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") + ); + + assertEquals("Fill in a phonenumber with 8 digits", exception.getMessage()); + assertNull(repo.insertedUser); + } + + 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 RecordingPasswordHasher implements PasswordHasher { + private final String hashToReturn; + private String lastPasswordInput; + + private RecordingPasswordHasher(String hashToReturn) { + this.hashToReturn = hashToReturn; + } + + @Override + public String hash(String password) { + lastPasswordInput = password; + return hashToReturn; + } + } + + private static class RecordingUserRepository implements UserRepository { + private boolean emailExists; + private boolean usernameExists; + private User insertedUser; + + @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 Optional.empty(); + } + + + @Override + public boolean existsByEmail(String email) { + return emailExists; + } + + @Override + public boolean existsByUsername(String username) { + return usernameExists; + } + + @Override + public void insert(User user) { + insertedUser = user; + } + } +} diff --git a/src/test/java/application/user/UserStatisticsTest.java b/src/test/java/application/user/UserStatisticsTest.java new file mode 100644 index 0000000..da904cb --- /dev/null +++ b/src/test/java/application/user/UserStatisticsTest.java @@ -0,0 +1,132 @@ +package application.user; + +import domain.user.User; +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; + +public class UserStatisticsTest { + + @Test + void userFavoriteOrganizationsReturnsListFromDonationDao() throws Exception { + FakeDonationDao fakeDao = new FakeDonationDao(); + fakeDao.favoriteOrganizationsToReturn = List.of( + "Org1 (3 donasjoner)", + "Org2 (2 donasjoner)" + ); + + UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + User user = createUserWithId(42L); + + List result = statistics.userFavoriteOrganizations(user); + + assertEquals(List.of("Org1 (3 donasjoner)", "Org2 (2 donasjoner)"), result); + assertEquals(42L, fakeDao.lastUserIdForFavorites); + } + + @Test + void userDonationsReturnsListFromDonationDao() throws Exception { + FakeDonationDao fakeDao = new FakeDonationDao(); + fakeDao.userDonationsToReturn = List.of( + "Amount: 100, Date: 2026-04-15, Organization: Org1", + "Amount: 50, Date: 2026-04-16, Organization: Org2" + ); + + UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + 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(7L, fakeDao.lastUserIdForDonations); + } + + @Test + void userTotalDonationAmountReturnsValueFromDonationDao() throws Exception { + FakeDonationDao fakeDao = new FakeDonationDao(); + fakeDao.totalDonationAmountToReturn = "250.00"; + + UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + User user = createUserWithId(15L); + + String result = statistics.userTotalDonationAmount(user); + + assertEquals("250.00", result); + assertEquals(15L, fakeDao.lastUserIdForTotalAmount); + } + + @Test + void getTotalDonationsMadeReturnsValueFromDonationDao() throws Exception { + FakeDonationDao fakeDao = new FakeDonationDao(); + fakeDao.totalDonationsMadeToReturn = "5"; + + UserStatistics statistics = createStatisticsWithFakeDao(fakeDao); + User user = createUserWithId(99L); + + String result = statistics.getTotalDonationsMade(user); + + assertEquals("5", result); + assertEquals(99L, fakeDao.lastUserIdForTotalCount); + } + + + + private UserStatistics createStatisticsWithFakeDao(FakeDonationDao fakeDao) throws Exception { + UserStatistics statistics = new UserStatistics(); + + Field field = UserStatistics.class.getDeclaredField("donationDao"); + field.setAccessible(true); + field.set(statistics, fakeDao); + + return statistics; + } + + private User createUserWithId(long id) { + User user = new User("testuser", "12345678", "password", "test@example.com"); + user.setId(id); + return user; + } + + private static class FakeDonationDao extends DonationDao { + private List favoriteOrganizationsToReturn = List.of(); + private List userDonationsToReturn = List.of(); + private String totalDonationAmountToReturn = "0"; + private String totalDonationsMadeToReturn = "0"; + + private long lastUserIdForFavorites; + private long lastUserIdForDonations; + private long lastUserIdForTotalAmount; + private long lastUserIdForTotalCount; + + @Override + public List getFavoriteOrganizations(long userId) { + lastUserIdForFavorites = userId; + return favoriteOrganizationsToReturn; + } + + @Override + public List getUserDonations(long userId) { + lastUserIdForDonations = userId; + return userDonationsToReturn; + } + + @Override + public String getTotalDonationAmount(long userId) { + lastUserIdForTotalAmount = userId; + return totalDonationAmountToReturn; + } + + @Override + public String getTotalDonationsMade(long userId) { + lastUserIdForTotalCount = userId; + return totalDonationsMadeToReturn; + } + } +} diff --git a/src/test/java/integration/security/Sha256PasswordHasherTest.java b/src/test/java/integration/security/Sha256PasswordHasherTest.java new file mode 100644 index 0000000..67b360e --- /dev/null +++ b/src/test/java/integration/security/Sha256PasswordHasherTest.java @@ -0,0 +1,26 @@ +package integration.security; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class Sha256PasswordHasherTest { + @Test + void hashReturnsExpectedSha256ForKnownInput() { + Sha256PasswordHasher hasher = new Sha256PasswordHasher(); + + String result = hasher.hash("password"); + + assertEquals("5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8", result); + } + + @Test + void hashReturns64CharacterLowercaseHexString() { + Sha256PasswordHasher hasher = new Sha256PasswordHasher(); + + String result = hasher.hash("secret"); + + assertEquals(64, result.length()); + assertTrue(result.matches("[0-9a-f]{64}")); + } +}