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. 😎😎

Este curso envejece muy bien.
El profesor explica muy bien

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));
    }
}

un mejor metodo de busqueda

 public Collection<Movie> findMovieByDuration(int i, int i1) {
        Collection<Movie> allmovies = movieRepository.findAll();

        return   allmovies.stream().map(movie -> movie)
                .filter(fil -> fil.getMinutes() >= i && fil.getMinutes() <= i1)
                .collect(Collectors.toList());
    }

Genial muchas gracias 😃

Test By Name and Id

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

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

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));
    }
}

Gracias profesor!

Agradecido de todo el aprendizaje recibido 🎉

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

Magnifico