Commit 33b9b54f authored by Michal Řezník's avatar Michal Řezník
Browse files

test: add tests for movie-managment

parent 82314caa

microservices-monorepo/movies-management/pom.xml

+11 −1
Original line number Diff line number Diff line
@@ -30,6 +30,16 @@ 
			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>

			<version>2.4.0</version>

		</dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <scope>test</scope>

        </dependency>

		<dependency>

			<groupId>org.hibernate.orm</groupId>

			<artifactId>hibernate-core</artifactId>

			<scope>test</scope>

		</dependency>

	</dependencies>



</project>

microservices-monorepo/movies-management/src/test/java/cz/muni/fi/pa165/moviesmanagement/facade/MovieFacadeImplTest.java

0 → 100644
+225 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.moviesmanagement.facade;



import cz.muni.fi.pa165.moviesmanagement.dto.CreateMovieDto;

import cz.muni.fi.pa165.moviesmanagement.dto.MovieDto;

import cz.muni.fi.pa165.moviesmanagement.enums.MovieGenre;

import cz.muni.fi.pa165.moviesmanagement.mapper.MovieMapper;

import cz.muni.fi.pa165.moviesmanagement.model.Movie;

import cz.muni.fi.pa165.moviesmanagement.service.MovieService;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.mockito.InjectMocks;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Optional;



import static org.junit.jupiter.api.Assertions.*;

import static org.mockito.Mockito.*;





public class MovieFacadeImplTest {



    @Mock

    private MovieService movieService;



    @Mock

    private MovieMapper movieMapper;



    @InjectMocks

    private MovieFacadeImpl movieFacade;



    @BeforeEach

    public void setUp() {

        MockitoAnnotations.initMocks(this);

    }



    @Test

    public void getAllMovies_allCorrect_returnsListOfMovies() {

        // Arrange

        Movie movie = new Movie();

        MovieDto movieDto = new MovieDto();

        when(movieService.getAll()).thenReturn(Collections.singletonList(movie));

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        Collection<MovieDto> result = movieFacade.getAllMovies();



        // Assert

        assertFalse(result.isEmpty());

        assertEquals(1, result.size());

        assertTrue(result.contains(movieDto));

    }



    @Test

    public void getMovieById_allCorrect_returnsMovieDto() {

        // Arrange

        Movie movie = new Movie();

        MovieDto movieDto = new MovieDto();

        Long id = 1L;

        when(movieService.findById(id)).thenReturn(Optional.of(movie));

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        Optional<MovieDto> result = movieFacade.getMovieById(id);



        // Assert

        assertTrue(result.isPresent());

        assertEquals(movieDto, result.get());

    }



    @Test

    public void getMovieById_notFound_returnsEmptyResult() {

        // Arrange

        Long id = 1L;

        when(movieService.findById(id)).thenReturn(Optional.empty());



        // Act

        Optional<MovieDto> result = movieFacade.getMovieById(id);



        // Assert

        assertFalse(result.isPresent());

    }



    @Test

    public void getMoviesByGenre_allCorrect_returnsMovieDto() {

        // Arrange

        Movie movie = new Movie();

        MovieDto movieDto = new MovieDto();

        MovieGenre genre = MovieGenre.ACTION;

        when(movieService.findByGenre(genre)).thenReturn(Collections.singletonList(movie));

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        Collection<MovieDto> result = movieFacade.getMoviesByGenre(genre);



        // Assert

        assertFalse(result.isEmpty());

        assertEquals(1, result.size());

        assertTrue(result.contains(movieDto));

    }



    @Test

    public void getMovieByName_allCorrect_returnsMovieDzo() {

        // Arrange

        Movie movie = new Movie();

        MovieDto movieDto = new MovieDto();

        String name = "Test Movie";

        when(movieService.findByName(name)).thenReturn(Optional.of(movie));

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        Optional<MovieDto> result = movieFacade.getMovieByName(name);



        // Assert

        assertTrue(result.isPresent());

        assertEquals(movieDto, result.get());

    }



    @Test

    public void getMovieByName_notFoundName_returnsEmpty() {

        // Arrange

        String name = "Test Movie";

        when(movieService.findByName(name)).thenReturn(Optional.empty());



        // Act

        Optional<MovieDto> result = movieFacade.getMovieByName(name);



        // Assert

        assertFalse(result.isPresent());

    }





    @Test

    public void getPossibleGenres_AllCorrect_returnsGenresCollection() {

        // Arrange

        Collection<MovieGenre> genres = Arrays.asList(MovieGenre.values());

        when(movieService.getPossibleGenres()).thenReturn(genres);



        // Act

        Collection<MovieGenre> result = movieFacade.getPossibleGenres();



        // Assert

        assertFalse(result.isEmpty());

        assertEquals(genres.size(), result.size());

        assertTrue(result.containsAll(genres));

    }



    @Test

    public void addMovie_allCorrect_returnsMovieDto() {

        // Arrange

        CreateMovieDto createMovieDto = getSampleCreateMovieDto();

        Movie movie = new Movie();

        MovieDto movieDto = new MovieDto();

        when(movieMapper.convertToEntity(createMovieDto)).thenReturn(movie);

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        MovieDto result = movieFacade.addMovie(createMovieDto);



        // Assert

        assertNotNull(result);

        assertEquals(movieDto, result);

    }



    // Test pro updateMovie metodu

    @Test

    public void updateMovie_allCorrect_returnsMovieDto() {

        // Arrange

        MovieDto movieDto = new MovieDto();

        Movie movie = new Movie();

        when(movieMapper.convertToEntity(movieDto)).thenReturn(movie);

        when(movieMapper.convertToDto(movie)).thenReturn(movieDto);



        // Act

        MovieDto result = movieFacade.updateMovie(movieDto);



        // Assert

        assertNotNull(result);

        assertEquals(movieDto, result);

    }



    // Test pro deleteMovie metodu

    @Test

    public void deleteMovie_allCorrect_returnsTrue() {

        // Arrange

        Long id = 1L;

        Movie movie = new Movie();

        when(movieService.findById(id)).thenReturn(Optional.of(movie));



        // Act

        Boolean result = movieFacade.deleteMovie(id);



        // Assert

        assertTrue(result);

        verify(movieService, times(1)).delete(movie);

    }



    // Test pro deleteMovie metodu, když není nalezen žádný film

    @Test

    public void deleteMovie_notFoundId_returnsFalse() {

        // Arrange

        Long id = 1L;

        when(movieService.findById(id)).thenReturn(Optional.empty());



        // Act

        Boolean result = movieFacade.deleteMovie(id);



        // Assert

        assertFalse(result);

        verify(movieService, never()).delete(any());

    }



    public CreateMovieDto getSampleCreateMovieDto() {

        return new CreateMovieDto(

                "Test Movie",

                "Test Director",

                Collections.singletonList(MovieGenre.ACTION),

                "testImageUrl",

                Collections.singletonList("Test Actor")

        );

    }

}
 
 No newline at end of file

microservices-monorepo/movies-management/src/test/java/cz/muni/fi/pa165/moviesmanagement/mapper/MovieMapperTest.java

0 → 100644
+55 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.moviesmanagement.mapper;



import cz.muni.fi.pa165.moviesmanagement.dto.MovieDto;

import cz.muni.fi.pa165.moviesmanagement.model.Movie;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;



import static org.junit.jupiter.api.Assertions.assertEquals;

import static org.junit.jupiter.api.Assertions.assertNotNull;



public class MovieMapperTest {



    private MovieMapper movieMapper;



    @BeforeEach

    public void setUp() {

        movieMapper = new MovieMapper();

    }



    @Test

    public void convertToMovieDtoFromEntity_allCorrect_returnsMovieDto() {

        // Arrange

        Movie movie = new Movie();

        movie.setId(1L);

        movie.setName("Test Movie");

        movie.setDirector("Test Director");



        // Act

        MovieDto movieDto = movieMapper.convertToDto(movie);



        // Assert

        assertNotNull(movieDto);

        assertEquals(movie.getId(), movieDto.getId());

        assertEquals(movie.getName(), movieDto.getName());

        assertEquals(movie.getDirector(), movieDto.getDirector());

    }



    @Test

    public void convertToEntityFromMovieDto_allCorrect_returnsMovie() {

        // Arrange

        MovieDto movieDto = new MovieDto();

        movieDto.setId(1L);

        movieDto.setName("Test Movie");

        movieDto.setDirector("Test Director");



        // Act

        Movie movie = movieMapper.convertToEntity(movieDto);



        // Assert

        assertNotNull(movie);

        assertEquals(movieDto.getId(), movie.getId());

        assertEquals(movieDto.getName(), movie.getName());

        assertEquals(movieDto.getDirector(), movie.getDirector());

    }

}
 
 No newline at end of file

microservices-monorepo/movies-management/src/test/java/cz/muni/fi/pa165/moviesmanagement/repository/MovieRepositoryTest.java

0 → 100644
+102 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.moviesmanagement.repository;



import cz.muni.fi.pa165.moviesmanagement.enums.MovieGenre;

import cz.muni.fi.pa165.moviesmanagement.model.Movie;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

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

import org.mockito.Mock;

import org.mockito.junit.jupiter.MockitoExtension;



import java.util.Collection;

import java.util.Collections;

import java.util.Optional;



import static org.junit.jupiter.api.Assertions.*;

import static org.mockito.ArgumentMatchers.anyLong;

import static org.mockito.Mockito.*;



@ExtendWith(MockitoExtension.class)

public class MovieRepositoryTest {



    private MovieRepository movieRepository;



    @Mock

    private Movie mockedMovie;



    @BeforeEach

    void setUp() {

        movieRepository = new MovieRepository();

    }



    @Test

    void addMovie_allCorrect() {

        movieRepository.add(mockedMovie);

        assertEquals(1, movieRepository.getAll().size());

        assertTrue(movieRepository.getAll().contains(mockedMovie));

    }



    @Test

    void deleteMovie_allCorrect() {

        movieRepository.add(mockedMovie);

        movieRepository.delete(mockedMovie);

        assertTrue(movieRepository.getAll().isEmpty());

    }



    @Test

    void updateMovie_allCorrect() {

        movieRepository.add(mockedMovie);

        Movie updatedMovie = new Movie();

        updatedMovie.setId(mockedMovie.getId());

        movieRepository.update(updatedMovie);

        assertEquals(updatedMovie, movieRepository.findById(mockedMovie.getId()).get());

    }



    @Test

    void findById_allCorrect_returnsMovie() {

        movieRepository.add(mockedMovie);

        Optional<Movie> foundMovie = movieRepository.findById(mockedMovie.getId());

        assertTrue(foundMovie.isPresent());

        assertEquals(mockedMovie, foundMovie.get());

    }



    @Test

    void  findById_notFoundId_returnsEmpty() {

        Optional<Movie> foundMovie = movieRepository.findById(999L);

        assertTrue(foundMovie.isEmpty());

    }



    @Test

    void findByName_allCorrect_returnsMovie() {

        when(mockedMovie.getName()).thenReturn("Test Movie");

        movieRepository.add(mockedMovie);

        Optional<Movie> foundMovie = movieRepository.findByName("Test Movie");

        assertTrue(foundMovie.isPresent());

        assertEquals(mockedMovie, foundMovie.get());

    }



    @Test

    void findByName_notFound_returnsEmpty() {

        Optional<Movie> foundMovie = movieRepository.findByName("Non-existent Movie");

        assertTrue(foundMovie.isEmpty());

    }



    @Test

    void findByGenre_allCorrect_returnsMovieCollection() {

        Movie movie1 = new Movie();

        movie1.setGenres(Collections.singleton(MovieGenre.ACTION));

        Movie movie2 = new Movie();

        movie2.setGenres(Collections.singleton(MovieGenre.COMEDY));

        movieRepository.add(movie1);

        movieRepository.add(movie2);

        Collection<Movie> foundMovies = movieRepository.findByGenre(MovieGenre.ACTION);

        assertEquals(1, foundMovies.size());

        assertTrue(foundMovies.contains(movie1));

    }



    @Test

    void getPossibleGenres_allCorrect_returnsGenresCollections() {

        assertEquals(MovieGenre.values().length, movieRepository.getPossibleGenres().size());

    }

}

microservices-monorepo/movies-management/src/test/java/cz/muni/fi/pa165/moviesmanagement/rest/MovieControllerIT.java

0 → 100644
+143 −0
Original line number Diff line number Diff line 
package cz.muni.fi.pa165.moviesmanagement.rest;



import com.fasterxml.jackson.databind.ObjectMapper;

import cz.muni.fi.pa165.moviesmanagement.dto.CreateMovieDto;

import cz.muni.fi.pa165.moviesmanagement.dto.MovieDto;

import cz.muni.fi.pa165.moviesmanagement.enums.MovieGenre;

import cz.muni.fi.pa165.moviesmanagement.facade.MovieFacade;

import org.junit.jupiter.api.Test;

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

import org.mockito.ArgumentMatchers;

import org.mockito.junit.jupiter.MockitoExtension;

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

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

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

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

import org.springframework.http.MediaType;

import org.springframework.test.context.junit.jupiter.SpringExtension;

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

import java.util.Arrays;

import java.util.Collections;

import java.util.Optional;



import static org.mockito.Mockito.*;

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

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



@ExtendWith({SpringExtension.class, MockitoExtension.class})

@WebMvcTest(MovieController.class)

@AutoConfigureMockMvc

public class MovieControllerIT {



    @Autowired

    private MockMvc mockMvc;



    @MockBean

    private MovieFacade movieFacade;



    @Autowired

    private ObjectMapper objectMapper;



    @Test

    public void getAllMovies_allCorrect_returnsMovieDtoCollection() throws Exception {

        MovieDto movie = new MovieDto();

        movie.setId(1L);

        movie.setName("Test Movie");

        when(movieFacade.getAllMovies()).thenReturn(Collections.singletonList(movie));



        mockMvc.perform(get("/api/movies"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$[0].id").value(1))

                .andExpect(jsonPath("$[0].name").value("Test Movie"));

    }



    @Test

    public void getMovieById_allCorrect_returnsMovieDtoCollection() throws Exception {

        MovieDto movie = new MovieDto();

        movie.setId(1L);

        movie.setName("Test Movie");

        when(movieFacade.getMovieById(1L)).thenReturn(Optional.of(movie));



        mockMvc.perform(get("/api/movies/1"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$.id").value(1))

                .andExpect(jsonPath("$.name").value("Test Movie"));

    }



    @Test

    public void getMovieByName_allCorrect_returnsMovieDto() throws Exception {

        MovieDto movie = new MovieDto();

        movie.setId(1L);

        movie.setName("TestMovie");

        when(movieFacade.getMovieByName("TestMovie")).thenReturn(Optional.of(movie));



        mockMvc.perform(get("/api/movies/name/TestMovie"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$.id").value(1))

                .andExpect(jsonPath("$.name").value("TestMovie"));

    }



    @Test

    public void getMoviesByGenre_allCorrect_returnsMovieDtoCollection() throws Exception {

        MovieDto movie = new MovieDto();

        movie.setId(1L);

        movie.setName("Test Movie");

        when(movieFacade.getMoviesByGenre(ArgumentMatchers.any(MovieGenre.class)))

                .thenReturn(Collections.singletonList(movie));



        mockMvc.perform(get("/api/movies/genre/COMEDY"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$[0].id").value(1))

                .andExpect(jsonPath("$[0].name").value("Test Movie"));

    }



    @Test

    public void getGenres_allCorrect_returnsGenresValues() throws Exception {

        when(movieFacade.getPossibleGenres()).thenReturn(Arrays.asList(MovieGenre.values()));



        mockMvc.perform(get("/api/movies/genres"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$").isArray())

                .andExpect(jsonPath("$").isNotEmpty());

    }



    @Test

    public void addMovie_allCorrect_returnsMovieDto() throws Exception {

        CreateMovieDto createMovieDto = new CreateMovieDto(

                "Test Movie",

                "Test Director",

                Collections.singletonList(MovieGenre.ACTION),

                "testImageUrl",

                Collections.singletonList("Test Actor")

        );



        MovieDto movie = new MovieDto();

        movie.setId(1L);

        movie.setName("Test Movie");

        movie.setGenres(Collections.singleton(MovieGenre.COMEDY));

        when(movieFacade.addMovie(createMovieDto)).thenReturn(movie);



        mockMvc.perform(post("/api/movies")

                        .contentType(MediaType.APPLICATION_JSON)

                        .content(objectMapper.writeValueAsString(createMovieDto)))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$.id").value(1))

                .andExpect(jsonPath("$.name").value("Test Movie"));

    }



    @Test

    public void deleteMovie_allCorrect_returnsTrue() throws Exception {

        when(movieFacade.deleteMovie(1L)).thenReturn(true);



        mockMvc.perform(delete("/api/movies/1"))

                .andExpect(status().isOk())

                .andExpect(content().contentType(MediaType.APPLICATION_JSON))

                .andExpect(jsonPath("$").value(true));

    }

}