App de Películas: test de búsqueda de películas por su duración

Este profesor explica MUY bien

A mi me gustaría saber ¿en que fase del desarrollo es considerado una buena práctica el refactor?

Seria ideal un curso para sacarle el mayor potencial al IDE Intellij IDEA Ultimate.

Test adicional: Busqueda de películas por nombre o palabra clave.

import leidy.javatests.movies.data.MovieRepository;
import leidy.javatests.movies.model.Genre;
import leidy.javatests.movies.model.Movie;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

public class MovieServiceShould
{
    private MovieRepository repository;
    private MovieService kindMovie;

    @Before
    public void setup()
    {
        repository = Mockito.mock(MovieRepository.class);
        Mockito.when(repository.findAll()).thenReturn(
                Arrays.asList(
                        new Movie(1, "Dark Knight", 152, Genre.ACTION),
                        new Movie(2, "Memento", 113, Genre.THRILLER),
                        new Movie(3, "Kill Bill", 100, Genre.ACTION),
                        new Movie(4, "Scream", 111, Genre.HORROR),
                        new Movie(5, "Home Alone", 103, Genre.COMEDY),
                        new Movie(6, "Evil Dead", 120, Genre.HORROR),
                        new Movie(7, "Resident Evil", 120, Genre.ACTION)
                )
        );
        kindMovie = new MovieService(repository);
    }


    @Test
    public void return_movies_by_genre()
    {
       Collection<Movie> movies = kindMovie.findMoviesByGenre(Genre.HORROR);

        assertThat(getMovieIds(movies), is(Arrays.asList(4, 6)));
    }


    @Test
    public void return_movies_by_duration()
    {
        Collection<Movie> movies = kindMovie.findMoviesByDuration(100);
        List<String> moviesDuration = movies.stream().map(Movie::getName).collect(Collectors.toList());

        // return movie name
        assertThat(moviesDuration, is(Arrays.asList("Kill Bill")));

        // return movie id
        assertThat(getMovieIds(movies), is(Arrays.asList(3)));
    }


    @Test
    public void return_movie_by_name_or_keyword()
    {
        Collection<Movie> movies = kindMovie.findMovieByName("Evil");
        List<String> movieName = movies.stream().map(Movie::getName).collect(Collectors.toList());

        assertThat(movieName, is(Arrays.asList("Evil Dead", "Resident Evil")));
    }


    private List<Integer> getMovieIds(Collection<Movie> movies)
    {
        List<Integer> getId = movies.stream().map(movie -> movie.getId()).collect(Collectors.toList());

        return getId;
    }
}

Wow esa reducción de código al final me deja impresionado. 😎😎

Actualmente asserThat() se encuentra deprecado por lo cual realice mi propia implantación usando un asserTrue()

package com.softin.movies.service;

import com.softin.movies.data.MovieRepository;
import com.softin.movies.model.Genre;
import com.softin.movies.model.Movie;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

import java.util.Arrays;
import java.util.Collection;

import static org.junit.Assert.assertTrue;

public class MovieServiceShould {

    private MovieService movieService;

    @Before
    public void setUp() throws Exception {

        MovieRepository movieRepository = Mockito.mock(MovieRepository.class);

        Mockito.when(movieRepository.findAll()).thenReturn(
                Arrays.asList(
                        new Movie(1, "Dark Knight", 152, Genre.ACTION),
                        new Movie(2, "Memento", 113, Genre.THRILLER),
                        new Movie(3, "There's Something About Mary", 119, Genre.COMEDY),
                        new Movie(4, "Super 8", 112, Genre.THRILLER),
                        new Movie(5, "Scream", 111, Genre.HORROR),
                        new Movie(6, "Home Alone", 103, Genre.COMEDY),
                        new Movie(7, "Matrix", 136, Genre.ACTION)
                )
        );

        movieService = new MovieService(movieRepository);
    }

    @Test
    public void return_movies_by_genre() {
        Collection<Movie> movies = movieService.findMoviesByGenre(Genre.COMEDY);
        assertTrue(movies.stream().allMatch(movie -> movie.getGenre() == Genre.COMEDY));
    }

    @Test
    public void return_movies_by_length() {
        Collection<Movie> movies = movieService.findMoviesByLength(119);
        assertTrue(movies.stream().allMatch(movie -> movie.getMinutes() <= 119));
    }
}

Test Adicional: Búsqueda de Peliculas que empiezan con una letra.

MovieService.java

public Collection<Movie> findByName(String initialLetterName) {

        return movieRepository.findAll().stream()
                .filter(movie -> movie.getName().startsWith(initialLetterName)).collect(Collectors.toList());
    }

MovieService.test

@Test
    public void return_movies_by_first_letter_name() {

        Collection<Movie> movies = movieService.findByName("M");

        assertThat(getMoviesIds(movies), CoreMatchers.is(Arrays.asList(2, 7)));

    }

Este IDE es maravilloso! Ahorra mucho tiempo con los atajos

Hice las comprobaciones para los tests de esta forma (sin usar el método getMovieIds):

class MovieServiceShould {

    private MovieService movieService;

    @BeforeEach
    void setUp() {
        MovieRepository movieRepository = mock(MovieRepository.class);
        movieService = new MovieService(movieRepository);
        when(movieRepository.findAll()).thenReturn(Arrays.asList(
                new Movie(1, "Dark Knight", 152, ACTION),
                new Movie(2, "Memento", 113, THRILLER),
                new Movie(3, "There's Something About Mary", 119, COMEDY),
                new Movie(4, "Super 8", 112, THRILLER),
                new Movie(5, "Scream", 111, HORROR),
                new Movie(6, "Home Alone", 103, COMEDY),
                new Movie(7, "Matrix", 136, ACTION)
        ));
    }

    @Test
    void return_movies_by_genre() {
        Collection<Movie> moviesByGenre = movieService.findMoviesByGenre(Genre.COMEDY);

        moviesByGenre.forEach(movie -> assertEquals(COMEDY, movie.getGenre()));
    }

    @Test
    void return_movies_by_length() {
        Collection<Movie> moviesByLength = movieService.findMoviesByLength(119);

        moviesByLength.forEach(movie -> assertTrue(movie.getMinutes() <= 119));
    }
}

Este curso envejece muy bien.
El profesor explica muy bien

Excelente como se usa los Shortcuts o los trucos que te ofrece IntelliJ IDEA

Impresionante como se puede simplicar varias veces el código manteniendo su funcionalidad, muchas gracias por la clase instructor Ferran.

Genial, me gusta las partes donde simplificamos y mejor aun lo hacemos con ayuda del IDE, definitivamente es muy muy util.

Magnifico

Genial muchas gracias 😃

Test By Name and Id