Spring MongoDB @Indexed(unique=true)

[TM69]

Ich habe folgendes (gekürzt):

Model

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.DBRef;
import org.springframework.data.mongodb.core.mapping.Document;

import com.tmt.hurricane.model.communication.Communication;
import com.tmt.hurricane.model.company.Company;
import com.tmt.hurricane.model.jobs.Job;
import com.tmt.hurricane.model.user.UserDowntime;
import com.tmt.hurricane.model.user.WorkTime;

@Document(collection="users")
public class User {
    
    @Transient
     public static final String SEQUENCE_NAME = "user_sequence";
    
     @Id
    private long id;                                                                

    @DBRef
    private User created_by;                                                        
    private LocalDateTime created_at;                                                

    @DBRef
    private User updated_by;                                                        
    private LocalDateTime updated_at;                                       

    @DBRef
    private User deleted_by;                                                        
    private LocalDateTime deleted_at;                                                

    @NotBlank
    @Size(min = 1, max = 100)
    private String firstname;                                                        

    @NotBlank
    @Size(min = 1, max = 100)
    private String lastname;                                                        
    
    @NotBlank
    @Email
    @Indexed(unique=true)
    private String email;                                                            

    @NotBlank
    @Size(min = 6, max = 15)
    private String password;                                                        
    
    private boolean blocked;                                                        
    private boolean enabled;                                                        
    
    private String pictogram;                                                        

    @DBRef
    private Company company;                                                         
    public User(
            @NotBlank @Size(min = 1, max = 100) String firstname,
            @NotBlank @Size(min = 1, max = 100) String lastname,
            @NotBlank @Email String email,
            @NotBlank @Size(min = 6, max = 15) String password) {
        super();
        this.firstname = firstname;
        this.lastname = lastname;
        this.email = email;
        this.password = password;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public User getCreatedBy() {
        return created_by;
    }

    public void setCreatedBy(User created_by) {
        this.created_by = created_by;
    }

    public LocalDateTime getCreatedAt() {
        return created_at;
    }

    public void setCreatedAt(LocalDateTime created_at) {
        this.created_at = created_at;
    }

    public User getUpdatedBy() {
        return updated_by;
    }

    public void setUpdatedBy(User updated_by) {
        this.updated_by = updated_by;
    }

    public LocalDateTime getUpdatedAt() {
        return updated_at;
    }

    public void setUpdatedAt(LocalDateTime updated_at) {
        this.updated_at = updated_at;
    }

    public User getDeletedBy() {
        return deleted_by;
    }

    public void setDeletedBy(User deleted_by) {
        this.deleted_by = deleted_by;
    }

    public LocalDateTime getDeletedAt() {
        return deleted_at;
    }

    public void setDeletedAt(LocalDateTime deleted_at) {
        this.deleted_at = deleted_at;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


}

Repository:

import java.util.Optional;

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import User;

@Repository
public interface UserRepository extends MongoRepository<User, Long> {

    Optional<User> findByEmail(String email);
}

Service:

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Query;

import org.springframework.stereotype.Service;

import User;
import UserRepository;

@Service
public class UserService {

    private MongoOperations mongoOperations;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    SequenceGeneratorService sequenceGeneratorService;

    public User createUser(User creator, User user) throws ResourceNotFoundException, NotDefinedException {
        if (user == null)
            throw new NotDefinedException("UserService::createUser(" + creator + ", " + user + "): The adding user must not be zero");
        
        if ( creator != null ) {
            userRepository.findById(creator.getId())
                .orElseThrow(() -> new ResourceNotFoundException("UserService::createUser(" + creator + ", " + user + "): Creator not found with the id :: " + creator.getId()));
        }
        
        user.setId(sequenceGeneratorService.generateSequence(User.SEQUENCE_NAME));
        user.setCreatedBy(creator);
        user.setCreatedAt(LocalDateTime.now());
        
        return userRepository.save(user);
    }
        
    public final User updateUser(User updater, Long id, User user) throws ResourceNotFoundException, NotDefinedException {
           if (updater == null)
            throw new NotDefinedException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): The updater user must not be zero");
          
           if (user == null)
            throw new NotDefinedException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): The user to be updated must not be null");
        
        User foundUser = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("UserService::updateUser(User updater: " + updater + ", Long id: " + id + ", User user: " + user + "): User not found for this id :: " + id));
        
        foundUser.setUpdatedBy(updater);
        foundUser.setUpdatedAt(LocalDateTime.now());
        
        return userRepository.save(user);
    }   
        
    public final User deleteUser(User deleter, long id) throws ResourceNotFoundException, NotDefinedException  {
           if (deleter == null)
            throw new NotDefinedException("UserService::deleteUser(User deleter: " + deleter + ", long id: " + id + "): The deleter user must not be zero");

        User foundDeleter = userRepository.findById(deleter.getId())
                .orElseThrow(() -> 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(foundDeleter);
        user.setDeletedAt(LocalDateTime.now());
        
        return userRepository.save(user);
    }
        
    public final User undeleteUser(long id) throws ResourceNotFoundException {
        
        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);
    }
            
    public void removeUser(long id) throws ResourceNotFoundException {
        User user = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found for this id :: " + id));
        
        userRepository.delete(user);
    }
        
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> findUserById(long userId) {
        return userRepository.findById(userId);
    }
        
    public Optional<User> findUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
        
    public List<User> findByQuery(Query query) {
        return mongoOperations.find(query, User.class);
    }

und eine dazugehörigen JUnit5-Test

import static org.junit.jupiter.api.Assertions.*;

import java.util.Optional;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import User;
import UserService;

/**
 * test function for the user service
 */
@SpringBootTest
class UserServiceTest {
    
    @Autowired
    UserService userService;
    
    @Test
    void testCreateUserWithDuplicatedEmailAdressShouldThrowResourceNotFound() throws ResourceNotFoundException, NotDefinedException {
        // store creator
        String creatorFirstname = "firstname";
        String creatorLastname = "lastname";
        String creatorEmail = "email@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 createdUser2 = userService.createUser(foundCreator.get(), user2);
        Optional<User> foundUser2 = userService.findUserById(createdUser2.getId());

        assertTrue( foundUser2.isPresent(), "testCreateUserWithDuplicatedEmailAdressShouldThrowResourceNotFound(): User 1 (" + user2 + ") not stored");
        
        
        // clean up
        userService.removeUser(foundCreator.get().getId());
        userService.removeUser(foundUser1.get().getId());
    }
}

1. wie teste ich die Email, die nicht doppelt vorkommen darf? @Indexed(unique=true) scheint im Test nicht zu greifen
2. damit einhergehend wie handle ich es im Produktiv-Teil?

Und ja ich weis ich könnte es manual durch findByEmail() prüfen, in der UserService::createUser() - Funktionen