Ich habe folgende Entity:
Repository:
Serviceklasse:
Testklasse:
Im Testfall testCreateUserWithCreator erhalte ich folgende Fehlermeldung:
Java:
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.validator.constraints.Length;
@Entity
@Table(name="user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@JoinColumn(name = "created_by", referencedColumnName = "id")
@ManyToOne(fetch = FetchType.LAZY)
private User created_by;
@OneToMany(mappedBy = "created_by", fetch = FetchType.EAGER)
private List<User> userList;
@NotNull
@CreationTimestamp
private LocalDateTime created_at;
@OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)
@JoinColumn(name="updated_by")
private User updated_by;
private LocalDateTime updated_at;
@OneToOne(cascade = CascadeType.REMOVE, fetch=FetchType.EAGER)
@JoinColumn(name="deleted_by")
private User deleted_by;
private LocalDateTime deleted_at;
@NotNull
@NotBlank
@Length(min=3, max=255)
private String firstname;
@NotNull
@NotBlank
@Length(min=3, max=255)
private String lastname;
@NotNull
@NotBlank
@Email
@Length(min=3, max=255)
@Column(unique=true)
private String email;
@NotNull
@NotBlank
@Length(min=3, max=255)
private String password;
public User() {
}
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 List<User> getUserList() {
return userList;
}
public void setUserList(List<User> userList) {
this.userList = userList;
}
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 setDeleted_by(User deletedBy) {
this.deleted_by = deleted_by;
}
public LocalDateTime getDeletedAt() {
return deleted_at;
}
public void setDeleted_at(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;
}
@Override
public int hashCode() {
return Objects.hash(created_at, created_by, deleted_at, deleted_by, email, firstname, id, lastname, password,
updated_at, updated_by);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
return Objects.equals(created_at, other.created_at) && Objects.equals(created_by, other.created_by)
&& Objects.equals(deleted_at, other.deleted_at) && Objects.equals(deleted_by, other.deleted_by)
&& Objects.equals(email, other.email) && Objects.equals(firstname, other.firstname)
&& Objects.equals(id, other.id) && Objects.equals(lastname, other.lastname)
&& Objects.equals(password, other.password) && Objects.equals(updated_at, other.updated_at)
&& Objects.equals(updated_by, other.updated_by);
}
@Override
public String toString() {
return "User [id=" + id + ", created_by=" + created_by + ", userList=" + userList + ", created_at=" + created_at
+ ", updated_by=" + updated_by + ", updated_at=" + updated_at + ", deleted_by=" + deleted_by
+ ", deleted_at=" + deleted_at + ", firstname=" + firstname + ", lastname=" + lastname + ", email="
+ email + ", password=" + password + "]";
}
}Repository:
Code:
import java.util.Optional;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import com.tmt.mytestapp.user.model.User;
@Repository
public interface UserRepository extends CrudRepository<User, Long> {
Optional<User> findByEmail(String email);
}Serviceklasse:
Code:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.google.common.base.Preconditions;
import com.tmt.hurricane.global.exception.ResourceNotFoundException;
import com.tmt.mytestapp.user.model.User;
import com.tmt.mytestapp.user.repository.UserRepository;
import java.time.LocalDateTime;
import java.util.Optional;
import javax.transaction.Transactional;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
@Service
public class UserService {
private static Logger logger = LogManager.getLogger(UserService.class);
@Autowired
UserRepository userRepository;
public User createUser(User creator, User user) throws ResourceNotFoundException {
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());
user.setCreatedBy(creator);
user.setCreatedAt(LocalDateTime.now());
return userRepository.save(user);
}
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);
}
}Testklasse:
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 com.tmt.mytestapp.global.exception.ResourceNotFoundException;
import com.tmt.mytestapp.user.model.User;
@SpringBootTest
class UserServiceTest {
@Autowired
UserService userService;
@Test
void testCreateUserWithMinimalistValidData() throws ResourceNotFoundException, NullPointerException {
String firstname = "firstname";
String lastname = "lastname";
String email = "email@email.com";
String password = "password";
User user = new User();
user.setFirstname(firstname);
user.setLastname(lastname);
user.setEmail(email);
user.setPassword(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 testCreateUserWithCreator() throws ResourceNotFoundException, NullPointerException {
// store creator
String creatorFirstname = "firstname";
String creatorLastname = "lastname";
String creatorEmail = "createrl@email.com";
String creatorPassword = "password";
User creator = new User();
creator.setFirstname(creatorFirstname);
creator.setLastname(creatorLastname);
creator.setEmail(creatorEmail);
creator.setPassword(creatorPassword);
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();
user.setFirstname(userFirstname);
user.setLastname(userLastname);
user.setEmail(userEmail);
user.setPassword(userPassword);
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());
}
}Im Testfall testCreateUserWithCreator erhalte ich folgende Fehlermeldung:
ich verstehe nur nicht was hier gerad schiefläuft
