From dcb96315ab6d36c39ebb8275cb214c69334ec373 Mon Sep 17 00:00:00 2001 From: HeftyB Date: Fri, 18 Sep 2026 19:05:46 -0400 Subject: [PATCH 1/4] Add failing tests for UserServiceImp auth bugs Runs against the real service and H2, so the email lookup exercises the actual query rather than a mock. Five tests fail today: - checkIfValidOldPassword passes (hash, raw) to matches(), which takes (raw, hash), so the current password is never accepted - emailExist uses a substring match, so registering am@example.com is refused because sam@example.com exists - getUserByPasswordResetToken calls .get() on an empty Optional and throws instead of returning empty - getUser builds its not-found message with String.format("", ...), which is always blank - generateNewVerificationToken's format string has a %s but no argument, so the not-found path throws MissingFormatArgumentException [Ticket: #14] Co-Authored-By: Claude Opus 5 --- .../users/services/UserServiceImpTest.java | 125 ++++++++++++++++++ 1 file changed, 125 insertions(+) create mode 100644 src/test/java/com/heftyb/dms/users/services/UserServiceImpTest.java diff --git a/src/test/java/com/heftyb/dms/users/services/UserServiceImpTest.java b/src/test/java/com/heftyb/dms/users/services/UserServiceImpTest.java new file mode 100644 index 0000000..798458a --- /dev/null +++ b/src/test/java/com/heftyb/dms/users/services/UserServiceImpTest.java @@ -0,0 +1,125 @@ +package com.heftyb.dms.users.services; + +import com.heftyb.dms.crm.Employee; +import com.heftyb.dms.crm.repositories.EmployeeRepository; +import com.heftyb.dms.exceptions.DataNotFoundException; +import com.heftyb.dms.exceptions.UserAlreadyExistException; +import com.heftyb.dms.users.Role; +import com.heftyb.dms.users.User; +import com.heftyb.dms.users.UserDTO; +import com.heftyb.dms.users.repositories.RoleRepository; +import com.heftyb.dms.users.repositories.UserRepository; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.transaction.annotation.Transactional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +@SpringBootTest +@ActiveProfiles("test") +@Transactional +class UserServiceImpTest { + + private static final String PASSWORD = "correct-horse"; + + @Autowired + private UserService userService; + + @Autowired + private UserRepository userRepo; + + @Autowired + private EmployeeRepository employeeRepo; + + @Autowired + private RoleRepository roleRepo; + + @Autowired + private PasswordEncoder passwordEncoder; + + @BeforeEach + void createUserRole() { + roleRepo.save(new Role("USER")); + } + + @Test + void oldPasswordCheckAcceptsCurrentPassword() { + User sam = existingUser("sam", "sam@example.com"); + + assertThat(userService.checkIfValidOldPassword(sam, PASSWORD)).isTrue(); + } + + @Test + void oldPasswordCheckRejectsWrongPassword() { + User sam = existingUser("sam", "sam@example.com"); + + assertThat(userService.checkIfValidOldPassword(sam, "wrong-horse")).isFalse(); + } + + @Test + void registrationAllowsEmailContainedInAnExistingOne() { + existingUser("sam", "sam@example.com"); + + User am = userService.registerNewUserAccount(registration("am", "am@example.com")); + + assertThat(am.getEmail()).isEqualTo("am@example.com"); + } + + @Test + void registrationRejectsDuplicateEmailIgnoringCase() { + existingUser("sam", "sam@example.com"); + + assertThatThrownBy(() -> userService.registerNewUserAccount(registration("sam2", "SAM@example.com"))) + .isInstanceOf(UserAlreadyExistException.class); + } + + @Test + void unknownPasswordResetTokenYieldsEmpty() { + assertThat(userService.getUserByPasswordResetToken("no-such-token")).isEmpty(); + } + + @Test + void knownPasswordResetTokenYieldsItsUser() { + User sam = existingUser("sam", "sam@example.com"); + userService.createPasswordResetTokenForUser(sam, "reset-123"); + + assertThat(userService.getUserByPasswordResetToken("reset-123")) + .map(User::getId) + .contains(sam.getId()); + } + + @Test + void unknownVerificationTokenErrorNamesTheToken() { + assertThatThrownBy(() -> userService.getUser("no-such-token")) + .isInstanceOf(DataNotFoundException.class) + .hasMessageContaining("no-such-token"); + } + + @Test + void regeneratingUnknownVerificationTokenThrowsNotFound() { + assertThatThrownBy(() -> userService.generateNewVerificationToken("no-such-token")) + .isInstanceOf(DataNotFoundException.class) + .hasMessageContaining("no-such-token"); + } + + private User existingUser(String username, String email) { + return userRepo.save(new User(username, passwordEncoder.encode(PASSWORD), email, employee())); + } + + private UserDTO registration(String username, String email) { + return new UserDTO(username, PASSWORD, PASSWORD, email, employee()); + } + + private Employee employee() { + Employee e = new Employee(); + e.setFirstName("Sam"); + e.setLastName("Ortiz"); + e.setPreferredName("Sam"); + return employeeRepo.save(e); + } +} From c8fec809a3a2a7b942d12441b69f460c281f9909 Mon Sep 17 00:00:00 2001 From: HeftyB Date: Fri, 18 Sep 2026 19:07:17 -0400 Subject: [PATCH 2/4] Fix auth bugs in UserServiceImp - checkIfValidOldPassword: pass (raw, encoded) to matches() - emailExist: use the exact-match findByEmailIgnoreCase that already exists on UserRepository - getUserByPasswordResetToken: map the Optional instead of calling get() on it - getUser and generateNewVerificationToken: include the token in the not-found message; the latter no longer throws MissingFormatArgumentException in place of DataNotFoundException [Ticket: #14] Co-Authored-By: Claude Opus 5 --- .../heftyb/dms/users/services/UserServiceImp.java | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/heftyb/dms/users/services/UserServiceImp.java b/src/main/java/com/heftyb/dms/users/services/UserServiceImp.java index 02ad7f2..3d43996 100644 --- a/src/main/java/com/heftyb/dms/users/services/UserServiceImp.java +++ b/src/main/java/com/heftyb/dms/users/services/UserServiceImp.java @@ -50,8 +50,7 @@ public UserServiceImp(final UserRepository userRepo, private boolean emailExist(String email) { - List matchingEmails = userRepo.findByEmailContainingIgnoreCase(email); - return !matchingEmails.isEmpty(); + return userRepo.findByEmailIgnoreCase(email).isPresent(); } @Override @@ -80,7 +79,9 @@ public User registerNewUserAccount(final UserDTO userDto) { @Override public User getUser(String verificationToken) { VerificationToken token = verificationTokenRepo.findByToken(verificationToken) - .orElseThrow(() -> new DataNotFoundException(String.format("", verificationToken))); + .orElseThrow(() -> new DataNotFoundException(String.format( + "Cannot find VerificationToken %s", verificationToken + ))); return token.getUser(); } @@ -132,7 +133,7 @@ public VerificationToken getVerificationToken(String verificationToken) { public VerificationToken generateNewVerificationToken(String token) { VerificationToken newToken = verificationTokenRepo.findByToken(token).orElseThrow( () -> new DataNotFoundException(String.format( - "VerificationToken %s can't be found!" + "VerificationToken %s can't be found!", token )) ); newToken.updateToken(UUID.randomUUID().toString()); @@ -177,7 +178,7 @@ public PasswordResetToken getPasswordResetToken(String token) { @Override public Optional getUserByPasswordResetToken(String token) { - return Optional.ofNullable(passResetRepo.findByToken(token).get().getUser()); + return passResetRepo.findByToken(token).map(PasswordResetToken::getUser); } @Override @@ -198,7 +199,7 @@ public void changeUserPassword(User user, String password) { @Override public boolean checkIfValidOldPassword(User user, String password) { - return passwordEncoder.matches(user.getPassword(), password); + return passwordEncoder.matches(password, user.getPassword()); } @Override From 35dafede517efa679362cd8e90311d8a70dc7295 Mon Sep 17 00:00:00 2001 From: HeftyB Date: Fri, 18 Sep 2026 19:08:02 -0400 Subject: [PATCH 3/4] Add failing tests for the registration password policy The Passay-backed @ValidPassword constraint exists but is not applied to anything, so UserDTO accepts any password, including none. The policy it implements is 8-30 characters with no whitespace. [Ticket: #14] Co-Authored-By: Claude Opus 5 --- .../dms/users/UserDTOValidationTest.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 src/test/java/com/heftyb/dms/users/UserDTOValidationTest.java diff --git a/src/test/java/com/heftyb/dms/users/UserDTOValidationTest.java b/src/test/java/com/heftyb/dms/users/UserDTOValidationTest.java new file mode 100644 index 0000000..3db92fa --- /dev/null +++ b/src/test/java/com/heftyb/dms/users/UserDTOValidationTest.java @@ -0,0 +1,62 @@ +package com.heftyb.dms.users; + +import jakarta.validation.ConstraintViolation; +import jakarta.validation.Validation; +import jakarta.validation.Validator; +import jakarta.validation.ValidatorFactory; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.Set; + +import static org.assertj.core.api.Assertions.assertThat; + +class UserDTOValidationTest { + + private static ValidatorFactory factory; + private static Validator validator; + + @BeforeAll + static void setUp() { + factory = Validation.buildDefaultValidatorFactory(); + validator = factory.getValidator(); + } + + @AfterAll + static void tearDown() { + factory.close(); + } + + @ParameterizedTest + @ValueSource(strings = {"12345678", "correct-horse", "a-29-character-password-here!"}) + void acceptsPasswordsBetween8And30CharactersWithoutWhitespace(String password) { + assertThat(passwordViolations(password)).isEmpty(); + } + + @ParameterizedTest + @ValueSource(strings = {"short", "has a space", "this-password-is-longer-than-thirty-chars"}) + void rejectsPasswordsOutsideThePolicy(String password) { + assertThat(passwordViolations(password)).isNotEmpty(); + } + + @Test + void rejectsMissingPassword() { + assertThat(passwordViolations(null)).isNotEmpty(); + } + + @Test + void explainsWhichRuleFailed() { + assertThat(passwordViolations("short")) + .extracting(ConstraintViolation::getMessage) + .anyMatch(message -> message.contains("8 or more characters")); + } + + private Set> passwordViolations(String password) { + UserDTO dto = new UserDTO(); + dto.setPassword(password); + return validator.validateProperty(dto, "password"); + } +} From 7fe985c0b222c2f775a9bb7d6db0cc0eed0fef7c Mon Sep 17 00:00:00 2001 From: HeftyB Date: Fri, 18 Sep 2026 19:09:45 -0400 Subject: [PATCH 4/4] Apply the password policy to UserDTO Annotate UserDTO.password with @NotNull and @ValidPassword. In the validator: - Treat null as valid so @NotNull reports it, instead of Passay failing on a null PasswordData. - Report Passay's own rule messages ("Password must be 8 or more characters in length.") instead of the generic "Invalid Password". This was the intent of the commented-out code, which used Guava's Joiner, a library this project does not have. [Ticket: #14] Co-Authored-By: Claude Opus 5 --- src/main/java/com/heftyb/dms/users/UserDTO.java | 5 +++++ .../dms/validation/PasswordConstraintValidator.java | 10 ++++++++-- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/heftyb/dms/users/UserDTO.java b/src/main/java/com/heftyb/dms/users/UserDTO.java index 56fed83..fb2e02d 100644 --- a/src/main/java/com/heftyb/dms/users/UserDTO.java +++ b/src/main/java/com/heftyb/dms/users/UserDTO.java @@ -1,12 +1,17 @@ package com.heftyb.dms.users; import com.heftyb.dms.crm.Employee; +import com.heftyb.dms.validation.ValidPassword; +import jakarta.validation.constraints.NotNull; /** * User data transfer object, used for mapping data from the request. */ public class UserDTO { private String username; + + @NotNull + @ValidPassword private String password; private String matchingPassword; private String email; diff --git a/src/main/java/com/heftyb/dms/validation/PasswordConstraintValidator.java b/src/main/java/com/heftyb/dms/validation/PasswordConstraintValidator.java index 1b12fc3..4c585ee 100644 --- a/src/main/java/com/heftyb/dms/validation/PasswordConstraintValidator.java +++ b/src/main/java/com/heftyb/dms/validation/PasswordConstraintValidator.java @@ -15,6 +15,11 @@ public void initialize(final ValidPassword arg0) { @Override public boolean isValid(final String password, final ConstraintValidatorContext context) { + // null is left to @NotNull, per the Bean Validation convention + if (password == null) { + return true; + } + // @formatter:off final PasswordValidator validator = new PasswordValidator(Arrays.asList( new LengthRule(8, 30), @@ -29,8 +34,9 @@ public boolean isValid(final String password, final ConstraintValidatorContext c if (result.isValid()) { return true; } -// context.disableDefaultConstraintViolation(); -// context.buildConstraintViolationWithTemplate(Joiner.on(",").join(validator.getMessages(result))).addConstraintViolation(); + context.disableDefaultConstraintViolation(); + context.buildConstraintViolationWithTemplate(String.join(" ", validator.getMessages(result))) + .addConstraintViolation(); return false; }