src/test/java/org/mikhail/service/HotelServiceTest.java - master - java56/Hotels

src/test/java/org/mikhail/service/HotelServiceTest.java
232 строки9 KB
Mikhail Gorbatenkov
48 - add missing tests
03 фев 2025, 15:07
03 фев 2025, 15:078e725e1
package org.mikhail.service;

import io.quarkus.hibernate.orm.panache.PanacheQuery;
import io.quarkus.panache.common.Page;
import io.quarkus.panache.common.Parameters;
import io.quarkus.panache.common.Sort;
import jakarta.persistence.LockModeType;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mikhail.dto.HotelDTO;
import org.mikhail.dto.response.HotelResponseDTO;
import org.mikhail.entity.AddressEntity;
import org.mikhail.entity.HotelCategory;
import org.mikhail.entity.HotelEntity;
import org.mikhail.entity.SortOrder;
import org.mikhail.exceptions.AddressLinkedToHotelException;
import org.mikhail.exceptions.AddressNotFoundException;
import org.mikhail.exceptions.HotelNotFoundException;
import org.mikhail.mapper.HotelMapper;
import org.mikhail.repository.AddressRepository;
import org.mikhail.repository.HotelRepository;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.*;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class HotelServiceTest {

    @Mock
    private HotelRepository hotelRepository;

    @Mock
    private AddressRepository addressRepository;

    @Mock
    private HotelMapper hotelMapper;

    private HotelService serviceUnderTest;

    @BeforeEach
    void setUp() {
        serviceUnderTest = new HotelService(hotelRepository, addressRepository, hotelMapper);
    }

    @DisplayName(value = "Должен вернуть HotelResponseDTO, когда добавляем отель")
    @Test
    void shouldReturnHotelResponseDTOWhenAddHotel() {
        // Given
        HotelDTO dto = new HotelDTO();
        dto.setName("Test Hotel");
        dto.setCategory(HotelCategory.ONE_STAR);
        dto.setAddressId(1L);
        dto.setNotes("Test notes");

        AddressEntity address = new AddressEntity();
        address.setId(1L);

        HotelEntity hotel = new HotelEntity();
        hotel.setId(1L);
        hotel.setName("Test Hotel");

        when(addressRepository.findById(1L)).thenReturn(address);
        when(hotelRepository.findByAddress(address)).thenReturn(Optional.empty());
        when(hotelMapper.toEntity(dto)).thenReturn(hotel);

        // When
        HotelResponseDTO result = serviceUnderTest.addHotel(dto);

        // Then
        verify(hotelRepository).persist(any(HotelEntity.class));
        assertNotNull(result);
        assertEquals("Test Hotel", result.getName());
        assertEquals(1L, result.getId());
    }

    @DisplayName(value = "Должен сгенерировать исключение, когда при добавлении отеля указанный адрес не найден.")
    @Test
    void shouldThrownExceptionWhenAddHotelAddressIdNotFound() {
        // Given
        HotelDTO dto = new HotelDTO();
        dto.setAddressId(999L);
        when(addressRepository.findById(999L)).thenReturn(null);

        // When & Then
        assertThrows(AddressNotFoundException.class,
                () -> serviceUnderTest.addHotel(dto));

        verify(hotelRepository, never()).persist(any(HotelEntity.class));
    }

    @DisplayName(value = "Должен сгенерировать исключение, когда при добавлении отеля адрес уже привязан.")
    @Test
    void shouldThrowExceptionWhenAddHotelAddressAlreadyExists() {
        // Given
        HotelDTO dto = new HotelDTO();
        dto.setAddressId(1L);

        AddressEntity address = new AddressEntity();
        address.setId(1L);

        HotelEntity existingHotel = new HotelEntity();
        when(addressRepository.findById(1L)).thenReturn(address);
        when(hotelRepository.findByAddress(address)).thenReturn(Optional.of(existingHotel));

        // When & Then
        assertThrows(AddressLinkedToHotelException.class,
                () -> serviceUnderTest.addHotel(dto));

        verify(hotelRepository, never()).persist(any(HotelEntity.class));
    }

    @DisplayName(value = "Должен вернуть сообщение, уведомляющее об успешном удалении, когда удаляем отель")
    @Test
    void shouldReturnSuccessfulMessageWhenDeleteHotel() {
        // Given
        Long id = 5L;
        HotelEntity hotel = new HotelEntity();
        hotel.setId(id);
        hotel.setName("Test Hotel");
        String expectedMessage = "Отель успешно удален";

        when(hotelRepository.findById(id)).thenReturn(hotel);

        // When
        String result = serviceUnderTest.deleteHotel(id);

        // Then
        assertNotNull(result);
        assertEquals(expectedMessage, result);
    }

    @DisplayName(value = "Должен вернуть исключение, когда при удалении отеля его идентификатор не найден в БД.")
    @Test
    void shouldThrowExceptionWhenDeleteHotelNotFound() {
        // Given
        Long id = 5L;
        when(hotelRepository.findById(id)).thenReturn(null);

        // When & Then
        assertThrows(HotelNotFoundException.class, () -> serviceUnderTest.deleteHotel(id));
        verify(hotelRepository, never()).delete(any(HotelEntity.class));
    }

    @DisplayName(value = "Должен вернуть список отелей, когда получаем все отели, имеющиеся в БД.")
    @Test
    void shouldReturnListOfHotelsWhenGetAllHotels() {
        // Given
        List<HotelEntity> hotels = List.of(new HotelEntity(), new HotelEntity());
        when(hotelRepository.listAll()).thenReturn(hotels);
        when(hotelMapper.toDto(any(HotelEntity.class))).thenReturn(new HotelDTO());

        // When
        List<HotelDTO> result = serviceUnderTest.getAllHotels();

        // Then
        assertEquals(2, result.size());
        verify(hotelRepository).listAll();
        verify(hotelMapper, times(2)).toDto(any(HotelEntity.class));
    }

    @DisplayName(value = "Должен обрабатывать большое количество отелей, когда тестируем производительность.")
    @Test
    void shouldHandlesLargeNumberHotelsWhenTestPerformance() {
        // Given
        List<HotelEntity> largeHotelList = new ArrayList<>();
        for (int i = 0; i < 10_000; i++) {
            HotelEntity hotel = new HotelEntity();
            hotel.setId((long) i);
            largeHotelList.add(hotel);
        }

        when(hotelRepository.listAll()).thenReturn(largeHotelList);
        when(hotelMapper.toDto(any(HotelEntity.class))).thenReturn(new HotelDTO());

        // When
        long startTime = System.currentTimeMillis();
        List<HotelDTO> result = serviceUnderTest.getAllHotels();
        long endTime = System.currentTimeMillis();

        // Then
        assertTrue((endTime - startTime) < 5000);
        assertEquals(10000, result.size());
    }

    @DisplayName(value = "Должен вернуть список отелей, когда получаю отели в постраничном формате")
    @Test
    void shouldReturnListOfHotelsWhenGetHotelsPaged() {
        // Given
        int page = 1;
        int size = 10;
        SortOrder sortOrder = SortOrder.ASCENDING;

        HotelEntity hotel1 = new HotelEntity();
        hotel1.setName("Hotel A");
        HotelEntity hotel2 = new HotelEntity();
        hotel2.setName("Hotel B");

        HotelDTO hotelDTO1 = new HotelDTO();
        hotelDTO1.setName("Hotel A");
        HotelDTO hotelDTO2 = new HotelDTO();
        hotelDTO2.setName("Hotel B");


        PanacheQuery<HotelEntity> panacheQuery = mock(PanacheQuery.class);

        when(hotelRepository.findAll(any(Sort.class))).thenReturn(panacheQuery);
        when(panacheQuery.page(any(Page.class))).thenReturn(panacheQuery);
        when(panacheQuery.stream()).thenReturn(Stream.of(hotel1, hotel2));
        when(hotelMapper.toDto(hotel1)).thenReturn(hotelDTO1);
        when(hotelMapper.toDto(hotel2)).thenReturn(hotelDTO2);

        // When
        List<HotelDTO> result = serviceUnderTest.getHotelsPaged(page, size, sortOrder);

        // Then
        assertEquals(2, result.size());
        assertEquals("Hotel A", result.get(0).getName());
        assertEquals("Hotel B", result.get(1).getName());

        verify(panacheQuery, times(1)).page(any(Page.class));
        verify(panacheQuery, times(1)).stream();
        verify(hotelMapper, times(2)).toDto(any(HotelEntity.class));
    }
}