Unit test updates

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.dao.UserRepository;
 
@@ -11,47 +12,53 @@
 
 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 UserRegister userRegister;
+
+    @BeforeEach
+    void setUp() {
+        repo = new RecordingUserRepository();
+        PasswordHasher 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 +67,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 +80,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());

src/test/java/application/user/UserSignInTest.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.dao.UserRepository;
 
@@ -11,155 +12,156 @@
 
 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() {
-        User user = new User("testuser", "12345678", "hashed-secret", "test@example.com");
-        PasswordHasher hasher = new FakePasswordHasher("hashed-secret");
-        UserRepository repo = new FakeUserRepository(Optional.of(user));
+        PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(user);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-        User result = userSignIn.execute("testuser", "secret");
+        User result = userSignIn.execute(USERNAME, RAW_PASSWORD);
 
         assertSame(user, result);
     }
 
     @Test
     void executeThrowsWhenLoginDoesNotExist() {
-        PasswordHasher hasher = new FakePasswordHasher("hashed-secret");
-        UserRepository repo = new FakeUserRepository(Optional.empty());
+        PasswordHasher hasher = new FakePasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(null);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
-            IllegalArgumentException.class,
-            () -> userSignIn.execute("missing-user", "secret")
+                IllegalArgumentException.class,
+                () -> userSignIn.execute("missing-user", RAW_PASSWORD)
         );
 
         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));
+        UserRepository repo = new FakeUserRepository(user);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
         IllegalArgumentException exception = assertThrows(
-            IllegalArgumentException.class,
-            () -> userSignIn.execute("testuser", "wrong-password")
+                IllegalArgumentException.class,
+                () -> userSignIn.execute(USERNAME, "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");
+    void executeDoesNotHashPasswordWhenLoginDoesNotExist() {
+        TrackingPasswordHasher hasher = new TrackingPasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(null);
 
         UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-        userSignIn.execute("  TestUser  ", "secret");
+        assertThrows(IllegalArgumentException.class,
+                () -> userSignIn.execute("missing-user", RAW_PASSWORD));
 
-        assertEquals("testuser", repo.lastLoginUsed);
+        assertFalse(hasher.wasCalled);
     }
 
-    private static class FakePasswordHasher implements PasswordHasher{
-        private final String hashToReturn;
-        private FakePasswordHasher(String hashToReturn) {
-            this.hashToReturn = hashToReturn;
-        }
+    @Test
+    void executePassesRawPasswordToHasher() {
+        RecordingPasswordHasher hasher = new RecordingPasswordHasher(HASHED_PASSWORD);
+        UserRepository repo = new FakeUserRepository(user);
 
-        @Override
-        public String hash(String password) {
-            return hashToReturn;
-        }
-    }
+        UserSignIn userSignIn = new UserSignIn(hasher, repo);
 
-    private static class FakeUserRepository implements UserRepository {
-        private final Optional<User> userToReturn;
+        userSignIn.execute(USERNAME, RAW_PASSWORD);
 
-        private FakeUserRepository(Optional<User> userToReturn) {
-            this.userToReturn = userToReturn;
-        }
+        assertEquals(RAW_PASSWORD, hasher.lastPassword);
+    }
 
-        @Override
-        public Optional<User> findByUsername(String username){
-            return Optional.empty();
-        }
+    private record FakePasswordHasher(String hashToReturn) implements PasswordHasher {
 
         @Override
-        public Optional<User> findByEmail(String email){
-            return Optional.empty();
+            public String hash(String password) {
+                return hashToReturn;
+            }
         }
 
-        @Override
-        public Optional<User> findByLogin(String login) {
-            return userToReturn;
-        }
+    private record FakeUserRepository(User userToReturn) implements UserRepository {
 
-        @Override
-        public boolean existsByEmail(String email) {
-            return false;
-        }
+      @Override
+      public Optional<User> findByUsername(String username) {
+        return Optional.empty();
+      }
 
-        @Override
-        public boolean existsByUsername(String username) {
-            return false;
-        }
+      @Override
+      public Optional<User> findByEmail(String email) {
+        return Optional.empty();
+      }
 
-        @Override
-        public void insert(User user) {
-        }
+      @Override
+      public Optional<User> findByLogin(String login) {
+        return Optional.ofNullable(userToReturn);
+      }
 
-        @Override
-        public void updateUser(User user) {}
-    }
+      @Override
+      public boolean existsByEmail(String email) {
+        return false;
+      }
 
-    private static class RecordingUserRepository implements UserRepository {
-        private final Optional<User> userToReturn;
-        private String lastLoginUsed;
+      @Override
+      public boolean existsByUsername(String username) {
+        return false;
+      }
 
-        private RecordingUserRepository(Optional<User> userToReturn) {
-            this.userToReturn = userToReturn;
-        }
+      @Override
+      public void insert(User user) {
+      }
 
         @Override
-        public Optional<User> findByUsername(String username) {
-            return Optional.empty();
-        }
+        public void updateUser(User user) {}
+    }
 
-        @Override
-        public Optional<User> findByEmail(String email) {
-            return Optional.empty();
-        }
+    private static class TrackingPasswordHasher implements PasswordHasher {
+        private final String hashToReturn;
+        private boolean wasCalled;
 
-        @Override
-        public Optional<User> findByLogin(String login) {
-            lastLoginUsed = login;
-            return userToReturn;
+        private TrackingPasswordHasher(String hashToReturn) {
+            this.hashToReturn = hashToReturn;
         }
 
         @Override
-        public boolean existsByEmail(String email) {
-            return false;
+        public String hash(String password) {
+            wasCalled = true;
+            return hashToReturn;
         }
+    }
 
-        @Override
-        public boolean existsByUsername(String username) {
-            return false;
-        }
+    private static class RecordingPasswordHasher implements PasswordHasher {
+        private final String hashToReturn;
+        private String lastPassword;
 
-        @Override
-        public void insert(User user) {
+        private RecordingPasswordHasher(String hashToReturn) {
+            this.hashToReturn = hashToReturn;
         }
 
         @Override
-        public void updateUser(User user) {}
+        public String hash(String password) {
+            lastPassword = password;
+            return hashToReturn;
+        }
     }
-}
-
+}