Bezugnehmend auf https://www.java-forum.org/thema/cast-fehler-spring-data-exists-boolean.199607/#post-1327993
sieht mein Repository momentan wie folgt aus:
die Service - Klasse
hierzu gibt es eine Reihe von Test-Funktionen
Alle, bis auf testUpdateUserWithValidData() werden erfolgreich durchlaufen.
In dieser Funktion hingegen ist in der Funktion public final User UserService::updateUser(User updater, Long id, User user)
ist an der Stelle
ist userRepository aufeinmal null, was natürlich zu einem Fehler an dieser Stelle führt. Und ich habe den halben Tag nicht herausfinden können, wieso? Vielleicht hat einer von euch eine Idee.
sieht mein Repository momentan wie folgt aus:
Java:
@Repository
public interface UserRepository extends CrudRepository<User, Long> {
@Query("SELECT u FROM User AS u WHERE lower(TRIM(u.email)) LIKE lower(TRIM(:email))")
public List<User> findByEmailRegEx(@Param("email") String email);
@Query("SELECT (count(u) > 0) FROM User AS u WHERE lower(TRIM(u.email)) LIKE lower(TRIM(:email))")
public boolean existsByEmailRegEx(@Param("email") String email);
public boolean existsById(long id);
}die Service - Klasse
Code:
@Service
public class UserService {
private static Logger logger = LogManager.getLogger(User.class);
@Autowired
private UserRepository userRepository;
public User createUser(User creator, User user) throws ResourceNotFoundException, DuplicateException {
logger.debug("UserService::createUser(" + creator + ", " + user + ")");
Preconditions.checkNotNull(user, "UserService::createUser(" + creator + ", " + user + "): The adding user must not be zero");
if ( creator != null && !userRepository.existsById(creator.getId()) )
throw new ResourceNotFoundException("UserService::createUser(" + creator + ", " + user + "): Creator not found with the id :: " + creator.getId());
if ( existsUserByEmail(user.getEmail()) )
throw new DuplicateException("UserService::createUser(" + creator + ", " + user + "): EMail (" + user.getEmail() + ") allready exists");
user.setCreatedBy(creator);
user.setCreatedAt(LocalDateTime.now());
return userRepository.save(user);
}
public final User updateUser(User updater, Long id, User user) throws ResourceNotFoundException, DuplicateException {
logger.debug("UserService::updateUser(" + updater + ", " + id + ", " + user + ")");
Preconditions.checkNotNull(updater, "UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): The updater user must not be zero");
Preconditions.checkNotNull(user, "UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): The user to be updated must not be null");
if ( !userRepository.existsById(updater.getId()) )
throw new ResourceNotFoundException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): Updater not found for this id :: " + updater.getId());
User foundUser = userRepository.findById(id) // ERROR: userRepository = null
.orElseThrow(() -> new ResourceNotFoundException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): User not found for this id :: " + id));
// find a user with not id but with the email user
List<User> userExists = this.findUserByEmail(user.getEmail());
if ( userExists.size() > 0 && userExists.get(0).getId() != id ) {
throw new DuplicateException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): Email already exists");
}
foundUser.setUpdatedBy(updater);
foundUser.setUpdatedAt(LocalDateTime.now());
foundUser.setFirstname(user.getFirstname());
foundUser.setLastname(user.getLastname());
foundUser.setEmail(user.getEmail());
foundUser.setPassword(user.getPassword());
return userRepository.save(foundUser);
}
public final User deleteUser(User deleter, long id) throws ResourceNotFoundException {
logger.debug("UserService::deleteUser(" + deleter + ", " + id + ")");
Preconditions.checkNotNull(deleter, "UserService::deleteUser(User deleter: " + deleter + ", long id: " + id + "): The deleter user must not be zero");
if ( !userRepository.existsById(deleter.getId()) )
throw new ResourceNotFoundException("UserService::deleteUser(User deleter: " + deleter + ", long id: " + id + "): The deleter not found");
User user = userRepository.findById(id)
.orElseThrow(() -> new ResourceNotFoundException("UserService::deleteUser(User deleter: " + deleter + ", long id: " + id + "): The user not found with the ID: " + id));
user.setDeletedBy(deleter);
user.setDeletedAt(LocalDateTime.now());
return userRepository.save(user);
}
public final User undeleteUser(long id) throws ResourceNotFoundException {
logger.debug("UserService::undeleteUser(" + id + ")");
User user = userRepository.findById(id)
.orElseThrow(() -> new ResourceNotFoundException("UserService::undeleteUser(long id: " + id + "): User not found for this id :: " + id));
user.setDeletedBy(null);
user.setDeletedAt(null);
return userRepository.save(user);
}
@Transactional
public void removeUser(long id) throws ResourceNotFoundException {
logger.debug("UserService::removeUser(" + id + ")");
User user = userRepository.findById(id)
.orElseThrow(() -> new ResourceNotFoundException("UserService::removeUser(" + id + "): User not found for this id"));
userRepository.delete(user);
}
public Optional<User> findUserById(long userId) {
logger.debug("UserService::findUserById(" + userId + ")");
return userRepository.findById(userId);
}
private List<User> findUserByEmail(String email) {
logger.debug("UserService::findUserByEmail(" + email + ")");
return userRepository.findByEmailRegEx(email);
}
private boolean existsUserByEmail(String email) {
logger.debug("UserService::existsUserByEmail(" + email + ")");
return userRepository.existsByEmailRegEx(email);
}
}hierzu gibt es eine Reihe von Test-Funktionen
Code:
@SpringBootTest
class UserServiceTest {
@Autowired
UserService userService;
@Test
void testCreateUserWithMinimalistValidDataShouldWork() throws ResourceNotFoundException, NullPointerException, DuplicateException {
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User(
firstname, // password
lastname, // lastname
email, // email
password // password
);
User createdUser = userService.createUser(null, user);
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testCreateUserWithMinimalistValidData(): User (" + user + ") not stored");
assertNull(foundUser.get().getCreatedBy(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getCreatedBy() + ") creator not null");
assertNotNull(foundUser.get().getCreatedAt(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getCreatedAt() + ") creator date not set");
assertNull(foundUser.get().getUpdatedBy(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getUpdatedBy() + ") updater was set");
assertNull(foundUser.get().getUpdatedAt(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getUpdatedAt() + ") updater date was set");
assertNull(foundUser.get().getDeletedBy(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getDeletedBy() + ") deleter was set");
assertNull(foundUser.get().getDeletedAt(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getDeletedAt() + ") deleter date was set");
assertEquals(firstname, foundUser.get().getFirstname(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getFirstname() + ") Firstname not identical with " + firstname);
assertEquals(lastname, foundUser.get().getLastname(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getLastname() + ") Lastname not identical with " + lastname);
assertEquals(email, foundUser.get().getEmail(), "testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getEmail() + ") Email not identical with " + email);
assertEquals(password, foundUser.get().getPassword(), "\"testCreateUserWithMinimalistValidData(): User (" + foundUser.get().getPassword() + ") Password not identical with " + password);
// clean up
userService.removeUser(foundUser.get().getId());
}
@Test
void testCreateUserWithCreatorShouldWork() throws ResourceNotFoundException, NullPointerException, DuplicateException {
// store creator
String creatorFirstname = "firstname";
String creatorLastname = "lastname";
String creatorEmail = "createrl@email.com";
String creatorPassword = "password";
User creator = new User(
creatorFirstname, // password
creatorLastname, // lastname
creatorEmail, // email
creatorPassword // password
);
User createdCreator = userService.createUser(null, creator);
Optional<User> foundCreator = userService.findUserById(createdCreator.getId());
assertTrue( foundCreator.isPresent(), "testCreateUserWithCreator(): Creator (" + createdCreator + ") not stored");
// stored user
String userFirstname = "user firstname";
String userLastname = "user lastname";
String userEmail = "useremail@email.com";
String userPassword = "userpassword";
User user = new User(
userFirstname, // password
userLastname, // lastname
userEmail, // email
userPassword // password
);
User createdUser = userService.createUser(foundCreator.get(), user);
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testCreateUserWithCreator(): User (" + createdUser + ") not stored");
assertEquals(createdUser.getId(), foundUser.get().getId(), "testCreateUserWithCreator(): User (" + foundUser.get() + ") creator not identical with " + createdUser.getId());
assertNotNull(foundUser.get().getCreatedBy(), "testCreateUserWithCreator(): User (" + foundUser.get() + ") creator date not set");
assertNull(foundUser.get().getUpdatedBy(), "testCreateUserWithCreator(): User (" + foundUser.get().getUpdatedBy() + ") updater was set");
assertNull(foundUser.get().getUpdatedAt(), "testCreateUserWithCreator(): User (" + foundUser.get().getUpdatedAt() + ") updater date was set");
assertNull(foundUser.get().getDeletedBy(), "testCreateUserWithCreator(): User (" + foundUser.get().getDeletedBy() + ") deleter was set");
assertNull(foundUser.get().getDeletedAt(), "testCreateUserWithCreator(): User (" + foundUser.get().getDeletedAt() + ") deleter date was set");
assertEquals(userFirstname, foundUser.get().getFirstname(), "testCreateUserWithCreator(): User (" + foundUser.get() + ") firstname not identical with " + userFirstname);
assertEquals(userLastname, foundUser.get().getLastname(), "testCreateUserWithCreator(): User (" + foundUser.get() + ") lastname not identical with " + userLastname);
assertEquals(userEmail, foundUser.get().getEmail(), "testCreateUserWithCreator(): User (" + foundUser.get() + ") email not identical with " + userEmail);
assertEquals(userPassword, foundUser.get().getPassword(), "\"testCreateUserWithCreator(): User (" + foundUser.get() + ") password not identical " + userPassword);
// clean up
userService.removeUser(foundCreator.get().getId());
userService.removeUser(foundUser.get().getId());
}
@Test
void testCreateUserWithNullUserDataShouldThrowNullPointerException() throws ResourceNotFoundException, NullPointerException {
assertThrows(NullPointerException.class, () -> userService.createUser(null, null), "testCreateUserWithNullUserData(): Create User with null user data didn't throw NullPointerException");
}
@Test
void testCreateUserWithNotExistsCreatorShouldThrowResourceNotFound() throws ResourceNotFoundException, NullPointerException {
// not exists creator
String notExistsCreatorFirstname = "fake user firstname";
String notExistsCreatorLastname = "fake user lastname";
String notExistsCreatorEmail = "fake@email.com";
String notExistsCreatorPassword = "fake password";
User notExistsCreator = new User(
notExistsCreatorFirstname, // password
notExistsCreatorLastname, // lastname
notExistsCreatorEmail, // email
notExistsCreatorPassword // password
);
notExistsCreator.setId(-1L);
// stored user
String userFirstname = "user firstname";
String userLastname = "user lastname";
String userEmail = "useremail@email.com";
String userPassword = "userpassword";
User user = new User(
userFirstname, // password
userLastname, // lastname
userEmail, // email
userPassword // password
);
assertThrows(ResourceNotFoundException.class, () -> userService.createUser(notExistsCreator, user), "testCreateUserWithNotExistsCreatorShouldThrowResourceNotFound(): The user was stored with not exist Creator (" + notExistsCreator + ")");
}
@Test
void testCreateUserWithDuplicatedEmailAdressShouldThrowDuplicateException() throws ResourceNotFoundException, NullPointerException, DuplicateException {
// store creator
String creatorFirstname = "firstname";
String creatorLastname = "lastname";
String creatorEmail = "creator@email.com";
String creatorPassword = "password";
User creator = new User(
creatorFirstname, // password
creatorLastname, // lastname
creatorEmail, // email
creatorPassword // password
);
User createdCreator = userService.createUser(null, creator);
Optional<User> foundCreator = userService.findUserById(createdCreator.getId());
assertTrue( foundCreator.isPresent(), "testCreateUserWithDuplicatedEmailAdressShouldThrowResourceNotFound(): Creator (" + createdCreator + ") not stored");
// stored user 1
String userFirstname1 = "user firstname 1";
String userLastname1 = "user lastname 1";
String userEmail1 = " useremai1@email.com";
String userPassword1 = "userpassword1";
User user1 = new User(
userFirstname1, // password
userLastname1, // lastname
userEmail1, // email
userPassword1 // password
);
User createdUser1 = userService.createUser(foundCreator.get(), user1);
Optional<User> foundUser1 = userService.findUserById(createdUser1.getId());
assertTrue( foundUser1.isPresent(), "testCreateUserWithDuplicatedEmailAdressShouldThrowResourceNotFound(): User 1 (" + user1 + ") not stored");
// try stored user 2
String userFirstname2 = "user firstname 2";
String userLastname2 = "user lastname 2";
String userEmail2 = " userEmai1@email.com ";
String userPassword2 = "userpassword1";
User user2 = new User(
userFirstname2, // password
userLastname2, // lastname
userEmail2, // email
userPassword2 // password
);
User foundCreatorUser = foundCreator.get();
assertThrows(DuplicateException.class, () -> userService.createUser(foundCreatorUser, user2), "testCreateUserWithDuplicatedEmailAdressShouldThrowResourceNotFound(): No DuplicateException is thrown for duplicate emails.");
// clean up
userService.removeUser(foundCreator.get().getId());
userService.removeUser(foundUser1.get().getId());
}
@Test
void testUpdateUserWithValidData() throws ResourceNotFoundException, NullPointerException, DuplicateException {
// create user
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User(
firstname, // password
lastname, // lastname
email, // email
password // password
);
User createdUser = userService.createUser(null, user);
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testUpdateUserWithValidData(): User (" + user + ") not stored");
// create updater
String creator_firstname = "creator firstname";
String creator_lastname = "creator lastname";
String creator_email = "creator_email@email.com";
String creator_password = "creator password";
User creator = new User(
creator_firstname, // password
creator_lastname, // lastname
creator_email, // email
creator_password // password
);
User creatorUser = userService.createUser(null, creator);
Optional<User> foundCreator = userService.findUserById(creatorUser.getId());
assertTrue( foundCreator.isPresent(), "testUpdateUserWithValidData(): Creator (" + creator + ") not stored");
// update user
String updatedFirstname = "updated firstname";
String updatedLastname = "updated lastname";
String updatedEmail = "new_email@email.com";
String updatedPassword = "new password";
User updatedUserData = new User(
updatedFirstname, // password
updatedLastname, // lastname
updatedEmail, // email
updatedPassword // password
);
User updatedUser = userService.updateUser(foundCreator.get(), foundUser.get().getId(), updatedUserData);
Optional<User> foundUpdatedUser = userService.findUserById(updatedUser.getId());
assertTrue( foundUpdatedUser.isPresent(), "testUpdateUserWithValidData(): Updated User (" + updatedUser + ") not stored");
assertEquals(foundUser.get().getId(), foundUpdatedUser.get().getId(), "testCreateUserWithMinimalistValidData(): User (" + foundUpdatedUser.get() + ") ID not identical with " + foundUser.get().getId());
assertNull(foundUpdatedUser.get().getCreatedBy(), "testUpdateUserWithValidData(): Updated User (" + foundUpdatedUser.get() + ") creator was set to null");
assertNotNull(foundUpdatedUser.get().getCreatedAt(), "testUpdateUserWithValidData(): Updated User (" + foundUpdatedUser.get() + ") creator date was set to null");
assertEquals(foundCreator.get().getId(), foundUpdatedUser.get().getUpdatedBy().getId(), "testUpdateUserWithValidData(): Updated User (" + foundUpdatedUser.get().getUpdatedBy() + ") updater was not set to " + foundCreator.get().getId());
assertNotNull(foundUpdatedUser.get().getUpdatedAt(), "testUpdateUserWithValidData(): Updated User (" + foundUpdatedUser.get() + ") updater date was not set");
assertNull(foundUpdatedUser.get().getDeletedBy(), "testUpdateUserWithValidData(): updated User (" + foundUpdatedUser.get() + ") deleter was set");
assertNull(foundUpdatedUser.get().getDeletedAt(), "testUpdateUserWithValidData(): Updated User (" + foundUpdatedUser.get() + ") deleter date was set");
assertEquals(updatedFirstname, foundUpdatedUser.get().getFirstname(), "testCreateUserWithMinimalistValidData(): User (" + foundUpdatedUser.get() + ") Firstname not identical with " + updatedFirstname);
assertEquals(updatedLastname, foundUpdatedUser.get().getLastname(), "testCreateUserWithMinimalistValidData(): User (" + foundUpdatedUser.get() + ") Lastname not identical with " + updatedLastname);
assertEquals(updatedEmail, foundUpdatedUser.get().getEmail(), "testCreateUserWithMinimalistValidData(): User (" + foundUpdatedUser.get() + ") Email not identical with " + updatedEmail);
assertEquals(updatedPassword, foundUpdatedUser.get().getPassword(), "testCreateUserWithMinimalistValidData(): User (" + foundUpdatedUser.get() + ") Password not identical with " + updatedPassword);
// clean up
userService.removeUser(foundCreator.get().getId());
userService.removeUser(foundUser.get().getId());
}
@Test
void testRemovedUserWithInvalidIndexShouldThrowResourceNotFoundException() throws ResourceNotFoundException, NullPointerException, DuplicateException {
// create user
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User(
firstname, // password
lastname, // lastname
email, // email
password // password
);
User createdUser = userService.createUser(null, user);
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testRemovedUserWithInvalidIndexShouldThrowResourceNotFoundException(): User (" + user + ") not stored");
// test
assertThrows(ResourceNotFoundException.class, () -> userService.removeUser(-1), "testRemovedUserWithInvalidIndexShouldThrowResourceNotFoundException(): A ResourceNotFoundException was not thrown when id is not exists");
// clean up
userService.removeUser(foundUser.get().getId());
}
@Test
void testRemoveUser() throws ResourceNotFoundException, DuplicateException {
// create user
String creator_firstname = "creators firstname";
String creator_lastname = "creators lastname";
String creator_email = "email@email.com";
String creator_password = "creators password";
User creator = new User(
creator_firstname, // password
creator_lastname, // lastname
creator_email, // email
creator_password // password
);
User createdCreator = userService.createUser(null, creator);
Optional<User> foundCreator = userService.findUserById(createdCreator.getId());
assertTrue( foundCreator.isPresent(), "testRemoveUserAndLoadingData(): Creator (" + creator + ") not stored");
// create user with creator
String user_firstname = "user firstname";
String user_lastname = "user lastname";
String user_email = "user_email@email.com";
String user_password = "user password";
User user = new User(
user_firstname, // password
user_lastname, // lastname
user_email, // email
user_password // password
);
User createdUser = userService.createUser(createdCreator, user);
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testRemoveUser(): User (" + user + ") not stored");
// test
userService.removeUser(createdCreator.getId());;
Optional<User> deletedUser = userService.findUserById(createdCreator.getId());
assertTrue( deletedUser.isEmpty(), "testRemoveUser(): User (" + createdCreator + ") not deleted" );
// clean up
userService.removeUser(foundUser.get().getId());
}
@Test
void testFindUserByIdIfUserWithIdExistsShouldWork() throws ResourceNotFoundException, DuplicateException {
// create user
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User(
firstname, // password
lastname, // lastname
email, // email
password // password
);
User createdUser = userService.createUser(null, user);
// test
Optional<User> foundUser = userService.findUserById(createdUser.getId());
assertTrue( foundUser.isPresent(), "testFindUserByIdIfUserWithIdExistsShouldWork(): User (" + user + ") not stored");
// clean up
userService.removeUser(foundUser.get().getId());
}
@Test
void testFindUserByIdIfUserWithNotExistsId() throws ResourceNotFoundException, DuplicateException {
// create user
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User(
firstname, // password
lastname, // lastname
email, // email
password // password
);
User createdUser = userService.createUser(null, user);
// test
Optional<User> foundUser = userService.findUserById(999999);
assertTrue( foundUser.isEmpty(), "testFindUserByIdIfUserWithNotExistsId(): User (" + user + ") was found");
// clean up
userService.removeUser(createdUser.getId());
}
}In dieser Funktion hingegen ist in der Funktion public final User UserService::updateUser(User updater, Long id, User user)
ist an der Stelle
Code:
User foundUser = userRepository.findById(id) // ERROR: userRepository = null
.orElseThrow(() -> new ResourceNotFoundException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): User not found for this id :: " + id));ist userRepository aufeinmal null, was natürlich zu einem Fehler an dieser Stelle führt. Und ich habe den halben Tag nicht herausfinden können, wieso? Vielleicht hat einer von euch eine Idee.
