I am working on a feature to handle the persistence of UserRole entities with the following requirements:

1. If the User associated with the UserRole does not exist in the database, it should be created automatically when the UserRole is persisted. (Provided there is no user_id set in the User model)
2. However, if the User does not exist and the user_id provided is invalid (e.g., not conforming to certain validation criteria or simply does not exists in the database), the attempt to persist the UserRole should fail, and an appropriate exception should be thrown.

To clarify this behavior, consider the following entity structure:

@Entity
@Table(name = "user_roles")
public class UserRole implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    @JoinColumn(name = "user_id", referencedColumnName = "userId", nullable = false)
    private User user;

    @Column(name = "role", nullable = false)
    private String role;

    // Constructors, getters, setters, and toString() method as before
}

I need to ensure that:

• When a UserRole is attempted to be saved with an associated User that does not exist, the User should be created automatically unless the UserId is invalid.
• In the case of an invalid UserId, the persistence operation should fail, ideally with a clear and descriptive error.

For example, in the following test scenario:

@Given("I have a user role {string} for a non-existing user")
public void givenUserRoleForNonExistingUser(String role) {
    User nonExistingUser = new User();
    nonExistingUser.setUserId(1234567890L);
    nonExistingUser.setUsername("non_existing_user");
    nonExistingUser.setEmail("[email protected]");
    nonExistingUser.setPasswordHash("SuperSecret123");
    nonExistingUser.setCreatedAt(new Timestamp(System.currentTimeMillis()));
    nonExistingUser.setUpdatedAt(new Timestamp(System.currentTimeMillis()));

    UserRole userRole = new UserRole();
    userRole.setRole(role);
    userRole.setUser(nonExistingUser);

    ArrayList<UserRole> userRoles = new ArrayList<>();
    userRoles.add(userRole);
    userRolesTestContext.setUserRoles(userRoles);
}

@When("I save the user role")
public void whenSaveUserRole() {
    UserRole userRole = userRolesTestContext.getUserRoles().stream().findFirst().orElse(null);

    try {
        userRoleRepository.create(userRole);
        ArrayList<UserRole> userRoles = new ArrayList<>();
        userRoles.add(userRole);
        userRolesTestContext.setUserRoles(userRoles);
    } catch (Exception e) {
        userRolesTestContext.setException(e);
    }

    assertTrue("User role should be saved with an ID", userRole.getId() != null);
}

@Then("the operation should fail with an EntityNotFoundException")
public void thenFailWithEntityNotFoundExceptionForDelete() {
    // Verify that the operation failed with an EntityNotFoundException
    assertNotNull("There should be an exception thrown", userRolesTestContext.getException());
    assertEquals("The exception should be a type UserNotFoundException", UserNotFoundException.class, userRolesTestContext.getException().getClass());
}

How can I enforce these requirements in the code? Adding the CascadeType.PERSIST and CascadeType.MERGE does not seem to fix it.