Ich habe folgendes (gekürzt):
Model
Repository:
Service:
und eine dazugehörigen JUnit5-Test
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
Model
Java:
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:
Code:
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:
Code:
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
Code:
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