Commit 9fbff2fe authored by Matej Vavro's avatar Matej Vavro
Browse files

test: finished writing tests, added dependencies needed for the tests to run

parent 654a44f2

microservices-monorepo/recommendations/pom.xml

+14 −0
Original line number Diff line number Diff line
@@ -56,6 +56,20 @@ 
            <artifactId>mapstruct-processor</artifactId>

            <version>${mapstruct-processor.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <dependency>

            <groupId>com.h2database</groupId>

            <artifactId>h2</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>



    <build>

microservices-monorepo/recommendations/src/test/java/cz/muni/fi/pa165/recommendations/data/repository/MoviesRepositoryMockTest.java

0 → 100644
+18 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.recommendations.data.repository;



import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;



@DataJpaTest

class MoviesRepositoryMockTest {



    // prepared for next milestone



    @Autowired

    private MoviesRepositoryMock moviesRepository;



    @Autowired

    private TestEntityManager testEntityManager;



}

microservices-monorepo/recommendations/src/test/java/cz/muni/fi/pa165/recommendations/facade/RecommendationsFacadeTest.java

+35 −19
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ import static org.mockito.Mockito.verify; 


@ExtendWith(MockitoExtension.class)

public class RecommendationsFacadeTest {

    private final long movieId = 1L;



    @Mock

    private RecommendationsService recommendationsService;
@@ -33,11 +34,10 @@ public class RecommendationsFacadeTest { 
    private RecommendationsFacade recommendationsFacade;



    @Test

    void getRecommendedMovies_WithValidId_ReturnsMovieDTOList() {

    void getRecommendedMovies_ValidId_MovieDTOList() {

        // Arrange

        long movieId = 1L;

        List<Movie> movies = TestDataFactory.createMovieList();

        List<MovieDTO> movieDTOs = TestDataFactory.createMovieDTOList(movies.size());

        List<MovieDTO> movieDTOs = TestDataFactory.createMovieDTOList();



        Mockito.when(recommendationsService.getRecommendedMovies(movieId)).thenReturn(movies);

        Mockito.when(movieMapper.mapToMovieDTOList(movies)).thenReturn(movieDTOs);
@@ -46,45 +46,61 @@ public class RecommendationsFacadeTest { 
        List<MovieDTO> result = recommendationsFacade.getRecommendedMovies(movieId);



        // Assert

        assertThat(result).isNotNull();

        assertThat(result.size()).isEqualTo(movieDTOs.size());

        assertThat(result).containsAll(movieDTOs);

        assertSuccessfulResult(result, movieDTOs);

        verify(recommendationsService, times(1)).getRecommendedMovies(movieId);

        verify(movieMapper, times(1)).mapToMovieDTOList(any(List.class));

    }



    @Test

    void getRecommendedMovies_WithInvalidId_ThrowsException() {

    void getRecommendedMovies_ValidIdSpecificCount_CountMovieDTOList() {

        // Arrange

        int count = 5;

        List<Movie> movies = TestDataFactory.createMovieList(count);

        List<MovieDTO> movieDTOs = TestDataFactory.createMovieDTOList(count);



        Mockito.when(recommendationsService.getRecommendedMovies(movieId, count)).thenReturn(movies);

        Mockito.when(movieMapper.mapToMovieDTOList(movies)).thenReturn(movieDTOs);



        // Act

        List<MovieDTO> result = recommendationsFacade.getRecommendedMovies(movieId, count);



        // Assert

        assertSuccessfulResult(result, movieDTOs);

        verify(recommendationsService, times(1)).getRecommendedMovies(movieId, count);

    }



    @Test

    void getRecommendedMovies_InvalidId_ThrowsException() {

        // Arrange

        long movieId = 154L;

        // RuntimeException is thrown by the original class

        Mockito.when(recommendationsService.getRecommendedMovies(movieId)).thenThrow(RuntimeException.class);



        // Act & Assert

        assertThrows(RuntimeException.class, () -> recommendationsFacade.getRecommendedMovies(movieId),

            "Exception was not thrown");



        verify(recommendationsService, times(1)).getRecommendedMovies(movieId);

        verify(movieMapper, times(0)).mapToMovieDTOList(any(List.class));

    }



    @Test

    void getRecommendedMovies_WithIdAndCount_ReturnsCustomNumberOfMovieDTOs() {

    void getRecommendedMovies_InvalidIdSpecificCount_ThrowsException() {

        // Arrange

        long movieId = 1L;

        int count = 5;

        List<Movie> movies = TestDataFactory.createMovieList(count);

        List<MovieDTO> movieDTOs = TestDataFactory.createMovieDTOList(movies.size());

        // RuntimeException is thrown by the original class

        Mockito.when(recommendationsService.getRecommendedMovies(movieId, count)).thenThrow(RuntimeException.class);



        Mockito.when(recommendationsService.getRecommendedMovies(movieId, count)).thenReturn(movies);

        Mockito.when(movieMapper.mapToMovieDTOList(movies)).thenReturn(movieDTOs);

        // Act & Assert

        assertThrows(RuntimeException.class, () -> recommendationsFacade.getRecommendedMovies(movieId, count),

            "Exception was not thrown");



        // Act

        List<MovieDTO> result = recommendationsFacade.getRecommendedMovies(movieId, count);

        verify(recommendationsService, times(1)).getRecommendedMovies(movieId, count);

        verify(movieMapper, times(0)).mapToMovieDTOList(any(List.class));

    }



        // Assert

    private void assertSuccessfulResult(List<MovieDTO> result, List<MovieDTO> movieDTOs) {

        assertThat(result).isNotNull();

        assertThat(result.size()).isEqualTo(movieDTOs.size());

        assertThat(result).containsAll(movieDTOs);

        verify(recommendationsService, times(1)).getRecommendedMovies(movieId, count);

        verify(movieMapper, times(1)).mapToMovieDTOList(any(List.class));

    }

}

microservices-monorepo/recommendations/src/test/java/cz/muni/fi/pa165/recommendations/mappers/MovieMapperTest.java

0 → 100644
+65 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.recommendations.mappers;



import cz.muni.fi.pa165.recommendations.api.MovieDTO;

import cz.muni.fi.pa165.recommendations.data.model.Movie;

import cz.muni.fi.pa165.recommendations.util.TestDataFactory;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.extension.ExtendWith;

import org.mapstruct.factory.Mappers;

import org.mockito.junit.jupiter.MockitoExtension;



import java.util.List;



import static org.assertj.core.api.Assertions.assertThat;



@ExtendWith(MockitoExtension.class)

public class MovieMapperTest {



    private MovieMapper movieMapper;



    @BeforeEach

    public void setup() {

        movieMapper = Mappers.getMapper(MovieMapper.class);

    }



    @Test

    void mapToMovieDTO_ValidMovie_MapsCorrectly() {

        // Arrange

        Movie movie = TestDataFactory.createMovie(1L);



        // Act

        MovieDTO movieDTO = movieMapper.mapToMovieDTO(movie);



        // Assert

        assertDtoAndEntityEquality(movieDTO, movie);

    }



    @Test

    void mapToMovieDTOList_ValidMovieList_MapsCorrectly() {

        // Arrange

        int count = 5;

        List<Movie> movies = TestDataFactory.createMovieList(count);



        // Act

        List<MovieDTO> movieDTOs = movieMapper.mapToMovieDTOList(movies);



        // Assert

        assertThat(movieDTOs).isNotNull().hasSize(count);

        for (int i = 0; i < count; i++) {

            Movie movie = movies.get(i);

            MovieDTO movieDTO = movieDTOs.get(i);

            assertDtoAndEntityEquality(movieDTO, movie);

        }

    }



    private void assertDtoAndEntityEquality(MovieDTO movieDTO, Movie movie) {

        assertThat(movieDTO).isNotNull();

        assertThat(movieDTO.id()).isEqualTo(movie.getId());

        assertThat(movieDTO.title()).isEqualTo(movie.getTitle());

        assertThat(movieDTO.director()).isEqualTo(movie.getDirector());

        assertThat(movieDTO.genres()).isEqualTo(movie.getGenres());

        assertThat(movieDTO.actors()).isEqualTo(movie.getActors());

        assertThat(movieDTO.rating()).isEqualTo(movie.getRating());

    }

}

microservices-monorepo/recommendations/src/test/java/cz/muni/fi/pa165/recommendations/rest/RecommendationsRestControllerIT.java

+80 −32
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.recommendations.rest;



/**

 * cannot write these tests as the application cannot be run

 */

//@SpringBootTest

//@AutoConfigureMockMvc

import cz.muni.fi.pa165.recommendations.api.MovieDTO;

import cz.muni.fi.pa165.recommendations.data.model.Movie;

import cz.muni.fi.pa165.recommendations.data.repository.MoviesRepositoryMock;

import cz.muni.fi.pa165.recommendations.mappers.MovieMapper;

import cz.muni.fi.pa165.recommendations.util.ObjectConveter;

import cz.muni.fi.pa165.recommendations.util.TestDataFactory;

import org.assertj.core.api.Assertions;

import org.junit.jupiter.api.Test;

import org.mockito.Mockito;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.boot.test.mock.mockito.MockBean;

import org.springframework.http.MediaType;

import org.springframework.test.web.servlet.MockMvc;

import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;



import java.nio.charset.StandardCharsets;

import java.util.List;

import java.util.Optional;



import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;



@SpringBootTest

@AutoConfigureMockMvc

public class RecommendationsRestControllerIT {

    private final long movieId = 1L;



    @MockBean

    private MoviesRepositoryMock repositoryMock;



    @Autowired

    private MockMvc mockMvc;



    @MockBean

    MovieMapper movieMapper;



    @Test

    void getRecommendedMovies_ValidId_SuccessAndRecommendations() throws Exception {

        // Arrange

        List<Movie> movies = TestDataFactory.createMovieList();

        Mockito.when(repositoryMock.findById(movieId))

            .thenReturn(Optional.of((TestDataFactory.createMovie(movieId))));

        Mockito.when(repositoryMock.getAll())

            .thenReturn(movies);



//    @MockBean

//    private MoviesRepositoryMock repositoryMock;

//

//    @Autowired

//    private MockMvc mockMvc;

//

//    @Test

//    void getRecommendedMovies_WithValidId_returnsRecommendations() throws Exception {

//        // Arrange

//        long movieId = 1L;

//        Mockito.when(repositoryMock.findById(movieId))

//            .thenReturn(Optional.of(TestDataFactory.createMovie(movieId)));

//

//        // Act

//        String responseJson = mockMvc.perform(get("/api/recommendations/{movieId}", movieId)

//                .accept(MediaType.APPLICATION_JSON_VALUE))

//            .andExpect(status().isOk())

//            .andReturn()

//            .getResponse()

//            .getContentAsString(StandardCharsets.UTF_8);

//        System.out.println(responseJson);

//        List<MovieDTO> response = ObjectConveter.convertJsonToListOfMovieDTO(responseJson);

//

//        // Assert

////        assertThat(responseJson).isEqualTo();

//        System.out.println(responseJson);

//        System.out.println(response);

        // Act

        String responseJson = mockMvc.perform(MockMvcRequestBuilders.get("/api/recommendations/{id}", movieId)

                .accept(MediaType.APPLICATION_JSON_VALUE))

            .andExpect(status().isOk())

            .andReturn()

            .getResponse()

            .getContentAsString(StandardCharsets.UTF_8);



        // Assert

        List<MovieDTO> response = ObjectConveter.convertJsonToListOfMovieDTO(responseJson);

        Assertions.assertThat(response).isNotNull();

    }



    @Test

    void getRecommendedMovies_ValidIdSpecificCount_SuccessAndRecommendations() throws Exception {

        // Arrange

        int count = 5;

        List<Movie> movies = TestDataFactory.createMovieList();

        Mockito.when(repositoryMock.findById(movieId))

            .thenReturn(Optional.of((TestDataFactory.createMovie(movieId))));

        Mockito.when(repositoryMock.getAll())

            .thenReturn(movies);



        // Act

        String responseJson = mockMvc.perform(MockMvcRequestBuilders

                .get("/api/recommendations/{id}?count={count}", movieId, count)

                .accept(MediaType.APPLICATION_JSON))

            .andExpect(status().isOk())

            .andReturn()

            .getResponse()

            .getContentAsString(StandardCharsets.UTF_8);



        // Assert

        List<MovieDTO> response = ObjectConveter.convertJsonToListOfMovieDTO(responseJson);

        Assertions.assertThat(response).isNotNull();

    }

}