Búsqueda de Películas por Atributos en Java

Curso Básico de Testing en Java

Contenido del curso

Bienvenida e Introducción

1
Testing en Java: JUnit, Mockito y TDD
01:47 min

Introducción a tests en software

2
Beneficios y tipos de tests automáticos y manuales en software
04:19 min

Preparación del IDE, proyecto y librerías

TDD

Tests en una aplicación

Requerimientos y tests

Conclusiones

24
Recomendaciones para Escribir Tests Efectivos en Programación
01:19 min

Tomar examen

En nuestra aplicación de películas queremos poder buscar por varios atributos a la vez. Por ejemplo, películas de acción que duren menos de 2 horas. ¿Cómo podemos hacer esto?

En MovieService vamos a implementar un método como el siguiente:

public Collection<Movie> findMoviesByTemplate(Movie template) { … }

En este caso, la película “template” que pasamos como argumento será una plantilla que puede tener varios atributos rellenados, para indicar por cuáles queremos buscar. Los atributos que tengan valor null no se usarán para la búsqueda.

Nota: Nos irá bien cambiar el tipo del atributo minutes a Integer en lugar de int, porque así podremos indicar un valor null. En Java, los tipos primitivos como int, boolean o double no pueden tener valor *null.

En un test podríamos buscar películas de acción de menos de 2h 30m de la siguiente manera:

String name = null; // no queremos buscar por nombre
Integer minutes = 150; // 2h 30m
Genre genre = Genre.ACTION;
Movie template = new Movie(name, minutes, genre);
Collection<Movie> movies =
	movieService.findMoviesByTemplate(template);
assertThat(getMovieIds(movies), is(Arrays.asList(7)) );

Nota: El código anterior se podría reducir (haciendo inline de las variables). En los tests es conveniente hacer esto, pues suele quedar más claro. El código compactado quedaría así:

assertThat(
 getMovieIds(movieService.findMoviesByTemplate(
	new Movie(null, 150, Genre.ACTION))),
  is(Arrays.asList(.......))
);

Piensa diferentes combinaciones de búsquedas y escribe tests para ellas. Por ejemplo, prueba a buscar por nombre y duración; por nombre y género; por nombre, género y duración; etc. Si añadiste el campo director (reto anterior), también prueba a buscar por director junto a otros atributos.

Si en la búsqueda indicamos el id de la película, se ignorarán los demás atributos, ya que al buscar por id no es necesario indicar ningún atributo más.

Si los minutos indicados son negativos, la función lanzará una IllegalArgumentException.

Búsqueda de Películas por Atributos en Java

Antonio Madrid

Estudiante

Aquí dejo mi reto: Clase Movie:

public class Movie {

    private Integer id;
    private String name;
    private Integer minutes;
    private Genre genre;
    private String director;

    public Movie(String name, Integer minutes, Genre genre) {
        this(null, name, minutes, genre);
    }

    public Movie(Integer id, String name, Integer minutes, Genre genre) {
        this.id = id;
        this.name = name;
        this.minutes = minutes;
        this.genre = genre;
        this.director = "";
    }

    public Movie(Integer id, String name, Integer minutes, Genre genre, String director) {
        this.id = id;
        this.name = name;
        this.minutes = minutes;
        this.genre = genre;
        this.director = director;
    }


    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Integer getMinutes() {
        return minutes;
    }

    public Genre getGenre() {
        return genre;
    }

    public String getDirector() { return director; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Movie movie = (Movie) o;
        return minutes == movie.minutes &&
                Objects.equals(id, movie.id) &&
                Objects.equals(name, movie.name) &&
                genre == movie.genre;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, minutes, genre);
    }
}

Clase MovieService:

public class MovieService {

    private MovieRepository movieRepository;

    public MovieService(MovieRepository movieRepository) {
        this.movieRepository = movieRepository;
    }

    public Collection<Movie> findMoviesByGenre(Genre genre) {
        return movieRepository.findAll().stream()
                .filter(movie -> movie.getGenre() == genre).collect(Collectors.toList());
    }

    public Collection<Movie> findMoviesByLength(Integer length) {
        return movieRepository.findAll().stream()
                .filter(movie -> movie.getMinutes() <= length).collect(Collectors.toList());
    }

    public Collection<Movie> findMoviesByName(String name){
        String NAME = name.toLowerCase();
        return movieRepository.findAll().stream().filter(movie -> movie.getName().toLowerCase().contains(NAME)).collect(Collectors.toList());
    }

    public Collection<Movie> findMoviesByDirector(String director) {
        String DIRECTOR = director.toLowerCase();
        return movieRepository.findAll().stream().filter(movie -> movie.getDirector().toLowerCase().contains(DIRECTOR)).collect(Collectors.toList());
    }

    public Collection<Movie> findMoviesByTemplate(Movie template) {

        Collection<Movie> movies = movieRepository.findAll();

        if ( template.getId() == null) {
            movies = templateFilter(template, movies);
        } else {
            movies = movies.stream().filter(movie -> movie.getId() == template.getId()).collect(Collectors.toList());
        }

        return movies;
    }

    private Collection<Movie> templateFilter(Movie template, Collection<Movie> movies) {
        if ( template.getName() != null) {
            movies = movies.stream().filter(movie -> movie.getName().toLowerCase().contains(template.getName().toLowerCase())).collect(Collectors.toList());
        }

        if (template.getDirector() != null) {
            movies = movies.stream().filter(movie -> movie.getDirector().toLowerCase().contains(template.getDirector().toLowerCase())).collect(Collectors.toList());
        }

        if (template.getMinutes() != null) {
            movies = movies.stream().filter(movie -> movie.getMinutes() <= template.getMinutes()).collect(Collectors.toList());
        }

        if (template.getGenre() != null) {
            movies = movies.stream().filter(movie -> movie.getGenre() == template.getGenre()).collect(Collectors.toList());
        }
        return movies;
    }

}

Aquí la clase de pruebas MovieServiceShould:

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, "Christopher Nolan"),
                        new Movie(2, "Memento", 113, Genre.THRILLER, "Christopher Nolan"),
                        new Movie(3, "There's Something About Mary", 119, Genre.COMEDY, "Peter Farrelly, Bobby Farrelly"),
                        new Movie(4, "Super 8", 112, Genre.THRILLER, "J. J. Abrams"),
                        new Movie(5, "Scream", 111, Genre.HORROR, "Wes Craven"),
                        new Movie(6, "Home Alone", 103, Genre.COMEDY, "Chris Columbus, Raja Gosnell, Peter Hewitt, Rod Daniel"),
                        new Movie(7, "Matrix", 136, Genre.ACTION, "Sisters Wachowski"),
                        new Movie(8, "Dark Knight Rises", 152, Genre.ACTION, "Christopher Nolan"),
                        new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Sisters Wachowski"),
                        new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Sisters Wachowski"),
                        new Movie(11, "Star Wars: The Force Awakens", 135, Genre.ACTION,"J. J. Abrams")
                )
        );

        movieService = new MovieService(movieRepository);
    }

    @Test
    public void return_movies_by_genre() {

        Collection<Movie> movies = movieService.findMoviesByGenre(Genre.COMEDY);
        assertThat(getMoviesIds(movies), is(Arrays.asList(3, 6)) );
    }

    @Test
    public void return_movies_by_length(){

        Collection<Movie> movies = movieService.findMoviesByLength(119);
        assertThat(getMoviesIds(movies), is(Arrays.asList(2, 3, 4, 5, 6)) );
    }

    @Test
    public void return_movies_by_name() {

        Collection<Movie> movies = movieService.findMoviesByName("dark Knight");
        assertThat(getMoviesIds(movies), is(Arrays.asList(1, 8)));
    }

    @Test
    public void return_movies_by_director() {

        Collection<Movie> movies = movieService.findMoviesByDirector("christopher Nolan");
        assertThat(getMoviesIds(movies), is(Arrays.asList(1, 2, 8)));
    }
// MARK
    @Test
    public void return_movies_by_action_genre_and_2_and_30_hours_lenght() {
        
        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(null, 150, Genre.ACTION));
        assertThat(getMoviesIds(movies), is(Arrays.asList(7, 9, 10, 11)) );
    }

    @Test
    public void return_movies_by_name_and_135_minutes_lenght() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie("the", 135, null));
        assertThat(getMoviesIds(movies), is(Arrays.asList(3, 11)) );
    }

    @Test
    public void return_movies_by_name_and_genre() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie("the", null, Genre.COMEDY));
        assertThat(getMoviesIds(movies), is(Arrays.asList(3)) );
    }

    @Test
    public void return_movies_by_name_by_action_genre_and_2_and_45_hours_lenght() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie("riseS", 165, Genre.ACTION));
        assertThat(getMoviesIds(movies), is(Arrays.asList(8)) );
    }

    @Test
    public void return_movies_by_director_and_2_and_30_hours_lenght() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(null, null, 150, null, "Nolan"));
        assertThat(getMoviesIds(movies), is(Arrays.asList(2)) );
    }

    @Test
    public void return_movies_by_director_and_name() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(null, "dark", null, null, "nolan"));
        assertThat(getMoviesIds(movies), is(Arrays.asList(1, 8)) );
    }

    @Test
    public void return_movies_by_director_and_thriller_genre() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(null, null, null, Genre.THRILLER, "NolaN"));
        assertThat(getMoviesIds(movies), is(Arrays.asList(2)) );
    }

    @Test
    public void return_movies_by_id_and_director() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(4, null, null, null, "abrams"));
        assertThat(getMoviesIds(movies), is(Arrays.asList(4)) );
    }

    @Test
    public void return_movies_by_id_and_2_and_30_hours_lenght() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(6, null, 150, null, null));
        assertThat(getMoviesIds(movies), is(Arrays.asList(6)) );
    }

    @Test
    public void negative_length() {

        Collection<Movie> movies =
                movieService.findMoviesByTemplate(new Movie(null, -150, null));
        assertThat(getMoviesIds(movies), is(Arrays.asList()) );
    }


    private List<Integer> getMoviesIds(Collection<Movie> movies) {
        return movies.stream().map(Movie::getId).collect(Collectors.toList());
    }
}

Puntualizar que el método templateFilter() puede ser refactorizado, ya que está casi repitiendo el mismo código que métodos como findMoviesByGenre(), findMoviesByLength(), findMoviesByName(), etc.

No encontré la manera de reutilizar esos métodos dentro de templateFilter().

Marco Antonio Jimenez Soto

Estudiante

Compañero Agradezco por darme una luz verde del ejercicio ,había logrado hacer el anterior , pero en este sí me sentía un poco perdido.

Muy valioso tu aporte.(Y)

Antonio Madrid

Estudiante

Tengo que confesar que me costó y que el primer acercamiento me agobió bastante por no saber donde meterle mano jajajaja.

Búsqueda de Películas por Atributos en Java

Bienvenida e Introducción

Testing en Java: JUnit, Mockito y TDD

Introducción a tests en software

Beneficios y tipos de tests automáticos y manuales en software

Preparación del IDE, proyecto y librerías

Uso de IntelliJ IDEA para Escribir y Probar Código Java

Creación de Tests Unitarios y Excepciones en Java

Escribir Tests en Java con JUnit: Instalación y Uso Básico

Organización de Tests en Funciones Separadas

Testing en Java con JUnit para Verificar Contraseñas

Simulación de Clases en Java con Moquito

Simulación de Pasarelas de Pago con Mockito

Organización y Mejora de Tests en jUnit

Función `isEmpty` y pruebas con JUnit en Java

TDD

Desarrollo Guiado por Pruebas (TDD): Conceptos y Ciclo Red-Green-Refactor

TDD para calcular años bisiestos en Java

Cálculo de Descuentos con Pruebas Unitarias en Java

Programación con TDD: Ejercicios FizzBuzz y Números Romanos

Tests en una aplicación

Organización de Aplicaciones en Capas: Interfaz, Negocio y Datos

Tests de Aplicación de Películas: Filtrado por Género y Duración

Pruebas de Búsqueda de Películas por Duración en Java

Implementación de MovieRepository con JDBC en Java

Tests de JDBC: Búsqueda e Inserción de Películas por ID

Búsqueda de Películas por Nombre y Director en App

Requerimientos y tests

Escritura de Tests a partir de Requerimientos Específicos

Búsqueda de Películas por Atributos en Java

Conclusiones

Recomendaciones para Escribir Tests Efectivos en Programación