test/java/Mommy/service/UserServiceTest.java - master - on-line-javalex/HW_NoSQL_JavaData

test/java/Mommy/service/UserServiceTest.java
187 строк8 KB
on-line-javalex
create: GlobalExceptionHandlerTest.java, UserControllerTest.java, UserMapperTest.java, MommyApplicationTest.java, UserServiceTest.java
12 май 2026, 13:59
Верифицирован
12 май 2026, 13:59311e66f
package Mommy.service;

import Mommy.dto.UserCreateRequest;
import Mommy.entity.User;
import Mommy.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.http.HttpStatus;
import org.springframework.web.server.ResponseStatusException;

import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    private User testUser;
    private UserCreateRequest createRequest;

    Integer age = 35;
    Integer id = 110011;
    String name = "Alice";
    String pocht = "alice@pocht.com";
    Long verthion = 11110L;

    @BeforeEach
    void setUp(){
        testUser = new User (name,pocht,age);
        testUser.setId(id.toString());
        testUser.setVersion(verthion);
        testUser.setDeleted(false);
        createRequest = new UserCreateRequest(pocht,name,age);
    }

    @Test
    void createShouldReturnSavedUserWhenEmailNotExists(){
        // Arrange - prepare
        when(userRepository.existsByEmail(pocht)).thenReturn(false);
        when(userRepository.save(any(User.class))).thenReturn(testUser); // if all save - return testUser\
        // Act
        User result = userService.create(testUser);
        // Assert
        assertThat(result).isEqualTo(testUser);
        verify(userRepository).existsByEmail(pocht);
    }

    @Test
    void createShouldThrowConflictWhenEmailExists() {
        when(userRepository.existsByEmail(pocht)).thenReturn(true);  // Arrange: email уже занят
        // Act&&Assert Exepted Exception
        assertThatThrownBy(()-> userService.create(testUser))
                .isInstanceOf(ResponseStatusException.class)
                .hasFieldOrPropertyWithValue("statusCode",HttpStatus.CONFLICT);
        verify(userRepository,never()).save(any());
    }

    @Test
    void findByIdShouldReturnActiveUser() {
        // Arrange: репозиторий находит активного пользователя по id
        when(userRepository.findByIdAndDeletedFalse(id.toString()))
                .thenReturn(Optional.of(testUser));
        // Act
        User result = userService.findById(id.toString());
        // Asserty
        assertThat(result).isEqualTo(testUser);
    }

    @Test
    void findByIdShouldThrowNotFoundWhenUserNotExistsOrDeleted() {
        // Arrange: при любом переданном id возвращаем пустой Optional,
        // что имитирует отсутствие пользователя в БД
        when(userRepository.findByIdAndDeletedFalse(anyString())).thenReturn(Optional.empty());
        // Act & Assert: ожидаем, что метод выбросит ResponseStatusException с кодом 404
        assertThatThrownBy(() -> userService.findById("missing"))
                .isInstanceOf(ResponseStatusException.class)
                .hasFieldOrPropertyWithValue("statusCode", HttpStatus.NOT_FOUND);
    }

    @Test
    void findByIdHardShouldReturnUserEvenIfDeleted() {
        // Arrange: делаем пользователя удалённым
        testUser.setDeleted(true);
        when(userRepository.findById(id.toString())).thenReturn(Optional.of(testUser));
        //Act
        User result = userService.findByIdHard(id.toString());
        // Assert: пользователь найден, даже несмотря на deleted=true
        assertThat(result).isNotNull();
        assertThat(result.getDeleted()).isTrue();
    }

    @Test
    void findByIdHardShouldThrowNotFoundWhenMissing() {
        when(userRepository.findById("missing")).thenReturn(Optional.empty());
        assertThatThrownBy(()->userService.findByIdHard("missing"))
                .isInstanceOf(ResponseStatusException.class)
                .hasFieldOrPropertyWithValue("statusCode",HttpStatus.NOT_FOUND);
    }

    @Test
    void findAllShouldReturnPageOfActiveUsers() {
        // Arrange: создаём объект Pageable (первая страница, размер 5)
        PageRequest pageable = PageRequest.of(0, 5);
        // Создаём объект Page, содержащий одного пользователя
        Page<User> page = new PageImpl<>(List.of(testUser), pageable, 1);
        when(userRepository.findByDeletedFalse(pageable)).thenReturn(page);
        // Act: вызываем findAll с параметром pageable
        Page<Mommy.dto.UserResponse> result = userService.findAll(pageable);
        // Assert: проверяем, что пагинация вернула одну запись и правильное имя
        assertThat(result.getTotalElements()).isEqualTo(1);
        assertThat(result.getContent()).hasSize(1);
        assertThat(result.getContent().get(0).getName()).isEqualTo(name);
    }

    @Test
    void updateShouldModifyAndSaveUser() {
        // Arrange: находим активного пользователя, затем при сохранении возвращаем его же
        when(userRepository.findByIdAndDeletedFalse("507f1f77bcf86cd799439011"))
                .thenReturn(Optional.of(testUser));
        when(userRepository.save(any(User.class))).thenReturn(testUser);
        // Создаём запрос с новыми данными
        UserCreateRequest updateReq = new UserCreateRequest("alice.new@example.com", "Alice Updated", 31);
        // Act
        User result = userService.update("507f1f77bcf86cd799439011", updateReq);
        // Assert: проверяем, что поля изменились
        assertThat(result.getName()).isEqualTo("Alice Updated");
        assertThat(result.getEmail()).isEqualTo("alice.new@example.com");
        assertThat(result.getAge()).isEqualTo(31);
        verify(userRepository).save(testUser); // метод save был вызван
    }

    @Test
    void deleteByIdShouldSetDeletedFlagAndSave() {
        // Arrange: находим активного пользователя
        when(userRepository.findByIdAndDeletedFalse("507f1f77bcf86cd799439011"))
                .thenReturn(Optional.of(testUser));
        // Act
        userService.deleteById("507f1f77bcf86cd799439011");
        // Assert: захватываем аргумент, переданный в save, и проверяем, что у него deleted = true
        ArgumentCaptor<User> captor = ArgumentCaptor.forClass(User.class);
        verify(userRepository).save(captor.capture());
        User savedUser = captor.getValue();
        assertThat(savedUser.getDeleted()).isTrue();
    }

    @Test
    void saveShouldReturnSavedUserWithVersionIncrementedWhenUsingRepositoryDirectly() {
        // Arrange: имитируем, что репозиторий увеличивает версию при сохранении
        when(userRepository.save(testUser)).thenAnswer(invocation -> {
            User u = invocation.getArgument(0);
            u.setVersion(u.getVersion() + 1); // увеличиваем версию на 1
            return u;
        });
        // Act: меняем имя и сохраняем
        testUser.setName("New Name");
        User result = userService.save(testUser);
        // Assert: имя изменилось, версия увеличилась
        assertThat(result.getName()).isEqualTo("New Name");
        assertThat(result.getVersion()).isEqualTo(verthion+1);
    }

    @Test
    void deleteAllShouldCallRepositoryDeleteAll() {
        // Act
        userService.deleteAll();
        // Assert: метод deleteAll репозитория был вызван ровно один раз
        verify(userRepository).deleteAll();
}
}