Búsqueda de Películas por Atributos en Java

Clase 23 de 24 • 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.

Gaiserick Jhonatan Ortiz Ramírez

student•

Les dejo mi aporte. De esta forma se crea una lista con las condiciones aplicables en base al template recibido y el código queda más elegante.

  public Collection<Movie> findByTemplate(Movie template) {

        if (template.getId() != null) {
            Movie movie = findById(template.getId());
            return movie != null ? Collections.singletonList(movie) : new ArrayList<>();
        }

        if (template.getMinutes() < 0) {
            throw new IllegalArgumentException("duration must be greater or equal than zero.");
        }

        List<Predicate<Movie>> filters = new ArrayList<>();

        if (template.getName() != null) {
            filters.add(movie -> movie.getName().toLowerCase().contains(template.getName().toLowerCase().trim()));
        }
        if (template.getMinutes() != null) {
            filters.add(movie -> movie.getMinutes() <= template.getMinutes());
        }
        if (template.getGenre() != null) {
            filters.add(movie -> movie.getGenre().equals(template.getGenre()));
        }
        if (template.getDirector() != null) {
            filters.add(movie -> movie.getDirector().toLowerCase().contains(template.getDirector().toLowerCase().trim()));
        }

        return repository.findAll().stream()
                .filter(movie -> filters.stream().allMatch(filter -> filter.test(movie)))
                .collect(Collectors.toList());
    }

Aquí los tests

  @Nested
    @DisplayName("when searching movies by multiple attributes")
    class SearchByTemplateMethod {

        @Test
        @DisplayName("using id")
        void whenUsingId() {
            Collection<Movie> movies = movieService.findByTemplate(new Movie(5, null, null, Genre.ACTION, null));
            assertEquals(Collections.singletonList(5), getMovieIds(movies));
        }

        @Test
        @DisplayName("using negative minutes")
        void whenUsingNegativeMinutes() {
            assertThrows(
                    IllegalArgumentException.class,
                    () -> movieService.findByTemplate(new Movie(null, null, -15, Genre.ACTION, null))
            );
        }

        @Test
        @DisplayName("using genre and minutes")
        void whenUsingGenreAndMinutes() {
            Collection<Movie> movies = movieService.findByTemplate(new Movie(null, null, 180, Genre.ACTION, null));
            assertEquals(Arrays.asList(1, 5), getMovieIds(movies));
        }

        @Test
        @DisplayName("using name and minutes")
        void whenUsingNameAndMinutes() {
            Collection<Movie> movies = movieService.findByTemplate(new Movie(null, "annabelle", 100, null, null));
            assertEquals(Collections.singletonList(7), getMovieIds(movies));
        }

        @Test
        @DisplayName("using director and minutes")
        void whenUsingDirectorAndMinutes() {
            Collection<Movie> movies = movieService.findByTemplate(new Movie(null, null, 110, null, "Chris"));
            assertEquals(Collections.singletonList(4), getMovieIds(movies));
        }
    }

y los resultados:

Marcos Emilio Velásquez Hidalgo

Interesante como organizaste los tests y como usaste una clase nested 🤔

David Galicia Gomez

Gracias, aprendi algo nuevo

Job Abdala Coronado Duran

Antonio Madrid

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

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)

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

Cesar David Ramírez Dimaté

El reto resultó bastante desafiante.

A continuación dejo el código del resultado ya que tocó hacer cambios importantes al enum de Genre. De paso adicional encontré algo que se llama Predicate, que define un lambda de un condicional específico, Optional para definir valores a variables nulas y and para agrupar varios predicados, todas estas opciones disponibles para Java 8.

Movie.java

public class Movie {
  ...
  private Integer minutes;
  private Genre genre;
  private String director;

  public Movie(String name, Integer minutes, Genre genre, String director) {
    this(null, name, minutes, genre, 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 getMinutes() {
    return minutes;
  }

  ...

  @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.equals(movie.minutes) &&
        Objects.equals(id, movie.id) &&
        Objects.equals(name, movie.name) &&
        genre == movie.genre &&
        director.equals(movie.director);
  }
}

Genre.java

package com.platzi.javatests.movies.model;

public enum Genre {
  ACTION, COMEDY, DRAMA, HORROR, THRILLER, EMPTY;

  @Override
  public String toString() {
    return this == EMPTY ? "" : this.name();
  }
}

MovieService.java

package com.platzi.javatests.movies.service;

import com.platzi.javatests.movies.model.Genre;
import com.platzi.javatests.movies.model.Movie;

import java.util.Collection;

public interface MovieService {
	...
  Collection<Movie> findMoviesByTemplate(Movie template);
}

MovieServiceImpl.java

...
public class MovieServiceImpl implements MovieService {
	...

  @Override
  public Collection<Movie> findMoviesByTemplate(Movie template) {
    if (template.getMinutes() != null && template.getMinutes() < 0) {
      throw new IllegalArgumentException();
    }

    Predicate<Movie> isName = n -> n.getName().toLowerCase().contains(
        Optional.ofNullable(template.getName()).orElse("").toLowerCase());
    Predicate<Movie> isMinutes = m -> m.getMinutes() <= Optional.ofNullable(template.getMinutes()).orElse(m.getMinutes());
    Predicate<Movie> isGenre = g -> g.getGenre().toString().contains(
        Optional.ofNullable(template.getGenre()).orElse(Genre.EMPTY).toString());
    Predicate<Movie> isDirector = d -> d.getDirector().toLowerCase().contains(
        Optional.ofNullable(template.getDirector()).orElse("").toLowerCase());

    return movieRepository.findAll().stream().filter(isName.and(isMinutes).and(isGenre).and(isDirector)).collect(Collectors.toList());
  }
}

MovieServiceShould.java

...
@RunWith(MockitoJUnitRunner.class)
public class MovieServiceShould {
  ...
  @Test
  public void returnMoviesByMovieTemplateWithDurationAndGenre() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
        new Movie(null, 152, ACTION, null)
      );

    assertThat(getMovieIds(movies), is(Arrays.asList(1, 7)));
  }

  @Test
  public void returnMoviesByMovieTemplateWithNameAndDuration() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
        new Movie("Super 8", 112, null, null)
      );

    assertThat(getMovieIds(movies), is(Collections.singletonList(4)));
  }

  @Test
  public void returnMoviesByMovieTemplateWithNameAndGenre() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
          new Movie("Super 8", null, THRILLER, null)
      );

    assertThat(getMovieIds(movies), is(Collections.singletonList(4)));
  }

  @Test
  public void returnMoviesByMovieTemplateWithNameAndGenreAndDuration() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
          new Movie("memento", 113, THRILLER, null)
      );

    assertThat(getMovieIds(movies), is(Collections.singletonList(2)));
  }

  @Test
  public void returnMoviesByMovieTemplateWithDirector() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
        new Movie(null, null, null, "nolan")
      );

    assertThat(getMovieIds(movies), is(Arrays.asList(1, 2)));
  }

  @Test(expected = IllegalArgumentException.class)
  public void returnError_whenDurationIsNegative() {
    Collection<Movie> movies =
      movieService.findMoviesByTemplate(
        new Movie(null, -120, null, null)
      );

    assertThat(getMovieIds(movies), is(Arrays.asList(1, 2)));
  }

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

Magdiel Linares

MovieRepositoryJdbc

public Collection<Movie> findByTemplate(Movie movie) {
        Collection<Movie> movies;
        StringBuilder parameters = new StringBuilder();
        List<Object> values = new ArrayList<>();

        if (movie.getId() != null && movie.getId() > 0) {
            movies = Arrays.asList(findById(movie.getId()));

        } else {
            if (movie.getName() != null && !movie.getName().isBlank()) {
                parameters.append(" NAME = ? ");
                values.add(movie.getName());
            }
            if (movie.getMinutes() != null) {
                if(movie.getMinutes() < 0) {
                    throw new IllegalArgumentException();
                }
                parameters.append((parameters.isEmpty() ? "" : " AND " ) + " MINUTES = ? ");
                values.add(movie.getMinutes());
            }
            if (movie.getGenre() != null) {
                parameters.append((parameters.isEmpty() ? "" : " AND " ) + " GENRE = ? ");
                values.add(movie.getGenre().toString());
            }
            if (movie.getDirector() != null) {
                parameters.append((parameters.isEmpty() ? "" : " AND " ) + " DIRECTOR = ? ");
                values.add(movie.getDirector());
            }
            movies = jdbcTemplate.query("SELECT * FROM MOVIES WHERE " + parameters, values.toArray(), movieMapper);
        }
        return movies;
    }
}

MovieRepositoryJdbcTest

    @Test
    void find_movie_by_name_and_genre() {
        Collection<Movie> movies = movieRepository.findByTemplate(new Movie("Matrix", null, Genre.ACTION, null));
        assertThat(movies, CoreMatchers.is(Arrays.asList(
                new Movie(3, "Matrix", 136, Genre.ACTION, "Director 2")
        )));
    }
    @Test
    void find_movie_by_name_and_duration() {
        Collection<Movie> movies = movieRepository.findByTemplate(new Movie("Memento", 113, null, null));
        assertThat(movies, CoreMatchers.is(Arrays.asList(new Movie(2, "Memento", 113, Genre.THRILLER, "Director 1"))));
    }
    @Test
    void find_movie_by_name_genre_and_duration() {
        Collection<Movie> movies = movieRepository.findByTemplate(new Movie("Memento", 113, Genre.THRILLER, null));
        assertThat(movies, CoreMatchers.is(Arrays.asList(new Movie(2, "Memento", 113, Genre.THRILLER, "Director 1"))));
    }
    @Test
    void find_movie_by_genre_and_director() {
        Collection<Movie> movies = movieRepository.findByTemplate(new Movie(null, null, Genre.ACTION, "Director 2"));
        assertThat(movies, CoreMatchers.is(Arrays.asList(new Movie(3, "Matrix", 136, Genre.ACTION, "Director 2"))));
    }

    @Test
    void find_movie_negative_minutes() {
        assertThrows(IllegalArgumentException.class, () -> movieRepository.findByTemplate(new Movie(null, -100, Genre.ACTION, "Director 2")));
    }

Vespaciano Forero Sanchez

La ultima parte del reto IllegalArgumentException En la clase MovieService.java, en el método findMoviesByTemplate. Quedaria si:

if (template.getMinutes() != null && template.getMinutes() > 0){
                movies = movies.stream().filter(movie -> movie.getMinutes() <= template.getMinutes())
                        .collect(Collectors.toList());
            } else throw new IllegalArgumentException("Id can't be 0 or negative");

Y en la clase MovieServiceShould.java, en el método return_movies_by_length_negative. Quedaria si:

@Test(expected = IllegalArgumentException.class)
    public void return_movies_by_length_negative() {
        Collection<Movie> movies = movieService.findMoviesByTemplate(new Movie(null, -119, Genre.COMEDY));
    }

Cristian Gómez

Juan Manuel Meneses Ibarra

Les comparto como genere el query para tomar los datos que obtenemos del template

@Override
    public Collection<Movie> findMoviesByTemplate(Movie template) {
        StringBuilder strBuilder = new StringBuilder("select * from movies where 1=1 ");
        List<Object> args = new ArrayList<>();
        if(template.getId() != null) {
            strBuilder.append("and id = ? ");
            args.add(template.getId());
        }
        if(template.getName() != null) {
            strBuilder.append("and lower(name) like ? ");
            args.add(String.format("%%%s%%", template.getName().toLowerCase()));
        }
        if(template.getGenre() != null) {
            strBuilder.append("and genre = ? ");
            args.add(template.getGenre().name());
        }
        if(template.getMinutes() > 0) {
            strBuilder.append("and minutes <= ? ");
            args.add(template.getMinutes());
        }
        if(template.getDirector() != null) {
            strBuilder.append("and lower(director) like ? ");
            args.add(String.format("%%%s%%", template.getDirector().toLowerCase()));
        }

        return jdbcTemplate.query(strBuilder.toString(), args.toArray(),  movieMapper);
    }

ESTIBEN COY

Buen codigo

Jose Manuel Ochoa Orellana

public Collection<Movie> findMoviesByTemplate(Movie template) {
        Collection<Movie> collectionMovie = movieRepository.finAll();
        if(template.getName() != null){
            collectionMovie = collectionMovie
                    .stream()
                    .filter(movie -> movie.getName()==template.getName())
                    .collect(Collectors.toList());
        }
        if (template.getMinutes() != null){
            collectionMovie = collectionMovie
                    .stream()
                    .filter(movie -> movie.getMinutes() <= template.getMinutes())
                    .collect(Collectors.toList());
        }
        if(template.getGenre() != null){
            collectionMovie = collectionMovie
                    .stream()
                    .filter(movie -> movie.getGenre() == template.getGenre())
                    .collect(Collectors.toList());
        }
        if(template.getDirector() != null){
            collectionMovie = collectionMovie
                    .stream()
                    .filter(movie -> movie.getDirector().equals(template.getDirector()))
                    .collect(Collectors.toList());
        }
        return collectionMovie;
    }

eduardo montaño cardenas

 private static String getNameDirector(Movie movie) {
        return (movie != null && movie.getName() != null)? movie.getDirector().toLowerCase():"noNameDirector";
    }

    public Collection<Movie> findMoviesByTemplate(Movie template) {
        if(template == null){
            throw new IllegalArgumentException("no hay filtros.");
        }
        return movieRepository.findAll().stream().filter(Objects::nonNull)
                .filter(movie ->
                        getNameMovie(movie).contains(getNameMovie(template))||
                        movie.getMinutes() <= template.getMinutes()||
                        getNameDirector(movie).contains(getNameDirector(template))||
                        movie.getGenre().equals(template.getGenre())
                )
                .collect(Collectors.toList());
    }

    private static String getNameMovie(Movie movie) {
        return (movie != null && movie.getName() != null)? movie.getName().toLowerCase():"noNameMovie";
    }

@Test
    public void should_return_filters_if_movie_not_null() {
        Collection<Movie> directorsMovie =  movieService.findMoviesByTemplate(
                new Movie(
                        null,
                        150,
                        null,
                        null
                ));
        assertThat(getIds(directorsMovie), is(Arrays.asList(2,3,4,5,6,7,8)));
    }

Santiago Yepes

Mi solución:

    public Collection<Movie> findMoviesByTemplate (Movie template) {
        if (template.getId() != null){
            return Collections.singletonList(this.movieRepository.findById((long)template.getId()));
        }
        return movieRepository.findAll().stream()
                .filter( movie ->
                        template.getName() == null || movie.getName().toLowerCase().contains(template.getName().toLowerCase())
                )
                .filter( movie -> template.getMinutes() == null || movie.getMinutes() <= template.getMinutes())
                .filter( movie -> template.getGenre() == null || movie.getGenre() == template.getGenre())
                .collect(Collectors.toList());
       
    }

joshua sainz

METODO

    public Collection<Movie> findMoviesByTemplate(Movie template) {
        // Si todos los atributos del objeto Movie son null, devuelve una lista vacía
        if (template.getMinutes() == null && template.getName() == null && template.getGenre() == null) {
            return new ArrayList<>();
        }
        // Si el atributo ID no es null, devuelve una lista de películas cuyo ID coincide con el ID de la plantilla
        if (template.getId() != null) {
            return movieRepo.findAll().stream().filter(movie -> movie.getId() == template.getId()).collect(Collectors.toList());
        }
        // Si los minutos de la plantilla son null o menores o iguales a cero, lanza una excepción
        if (template.getMinutes() == null || template.getMinutes() <= 0) {
            throw new IllegalArgumentException("Movie time can't be null and must be greater than 0 minutes");
        }
        // Filtra todas las películas del repositorio según los atributos de la plantilla
        // Si un atributo de la plantilla es null, se ignora ese atributo al filtrar las películas
        // Si un atributo de la plantilla no es null, solo las películas con el mismo valor para ese atributo pasan el filtro
        List<Movie> filteredMovies = movieRepo.findAll().stream().filter(movie -> {
            if (template.getMinutes() != null && movie.getMinutes() > template.getMinutes()) {
                return false;
            }
            if (template.getName() != null && !movie.getName().equals(template.getName())) {
                return false;
            }
            if (template.getGenre() != null && !movie.getGenre().equals(template.getGenre())) {
                return false;
            }
            return true; // Si la película pasa todos los filtros, se incluye en la lista filtrada
        }).collect(Collectors.toList());
        return filteredMovies;
    }

TEST

    @Test
    public void return_movies_by_template_with_title_and_duration() {
        String name = "The Avengers";
        Integer minutes = 143;
        Genre genre = null; // no buscamos por genero
        Movie template = new Movie(name, minutes, genre);

        Collection<Movie> movies = movieservice.findMoviesByTemplate(template);
        assertEquals(getIntegers(movies), Arrays.asList(1));
    }

    @Test
    public void return_movies_by_template_with_duration_and_genre() {
        String name = null; // no buscamos por nombre
        Integer minutes = 100;
        Genre genre = Genre.COMEDY;
        Movie template = new Movie(name, minutes, genre);

        Collection<Movie> movies = movieservice.findMoviesByTemplate(template);
        assertEquals(getIntegers(movies), Arrays.asList(2));
    }

    @Test(expected = IllegalArgumentException.class)
    public void return_movies_by_template_with_title_and_genre() {
        String name = "The Hangover";
        Integer minutes = null; // no buscamos por duración
        Genre genre = Genre.COMEDY;
        Movie template = new Movie(name, minutes, genre);

    ```

Johan Camilo Santiago Rodriguez

   public Collection<Movie> findMoviesByTemplate(Movie template) throws UnsupportedOperationException {
        List<Integer> moviesIds = movieRepository.findAll().stream().map(movie -> movie.getId())
                .collect(Collectors.toList());
        if (template.getId() != null) {
            moviesIds.retainAll(
                    findMoviesById(template.getId()).stream().map(movie -> movie.getId()).collect(Collectors.toList()));
        }
        if (template.getDirector() != null) {
            moviesIds.retainAll(findByDirector(template.getDirector()).stream().map(movie -> movie.getId())
                    .collect(Collectors.toList()));
        }
        if (template.getGenre() != null) {
            moviesIds.retainAll(findMoviesByGenre(template.getGenre()).stream().map(movie -> movie.getId())
                    .collect(Collectors.toList()));
        }
        if (template.getMinutes() != null&&template.getMinutes()>=0) {
            moviesIds.retainAll(findMoviesByLength(template.getMinutes()).stream().map(movie -> movie.getId())
                    .collect(Collectors.toList()));
        } else {
            throw new IllegalArgumentException("Los minutos indicados no pueden ser negativos");
        }
        if (template.getName() != null) {
            moviesIds.retainAll(
                    findByName(template.getName()).stream().map(movie -> movie.getId()).collect(Collectors.toList()));
        }

        Collection<Movie> movieTemplate = new ArrayList<Movie>();

        for (int i = 0; i < moviesIds.size(); i++) {
            movieTemplate.addAll(findMoviesById(moviesIds.get(i)));
        }
        return movieTemplate;
    }

Alexis David Sánchez Niaupari

Asi quedo uno de los metodos mas interesantes que eh hecho

public Collection<Movie> findMovieByTemplate(Movie movieTemplate) {
        int atributosNonNull = 0;

        /*Primero vamos a comprobar el numero de atributos no nulos
         * que tenemos en el template*/
        if (movieTemplate.getName() != null) {
            atributosNonNull++;
        }

        if (movieTemplate.getGenre() != null) {
            atributosNonNull++;
        }

        if (movieTemplate.getMinutes() != null) {
            atributosNonNull++;
        }
        /**Luego instanciaremos el objeto movies que son todas las peliculas que tenemos y el ArrayList<>() En donde meteremos las que nos regresen</>*/

        Collection<Movie> movies = movieRepositoryJdbc.findAll();
        Collection<Movie> moviesByTemplate = new ArrayList<>();

        for (Movie movie : movies) {
            /**Aqui implementaremos lo primero que nada que es que si se busca por id pues no mames, ya la tienes, el id es unico*/
            if (movieTemplate.getId() != null && Objects.equals(movieTemplate.getId(), movie.getId())) {
                moviesByTemplate.add(movie);
            } else {
                String error = "";
                switch (atributosNonNull) {
                    case 1:
                        if (movieTemplate.getName() != null) {
                            error = "el nombre";
                            //Aqui creo que podria reutilizar el codigo de find movieByName
                            if (movie.getName().toLowerCase().contains(movieTemplate.getName().toLowerCase())) {
                                moviesByTemplate.add(movie);
                            }
                        }
                        //En esta seccion comprobamos el genero de la pelicula
                        else if (movieTemplate.getGenre() != null && Objects.equals(movieTemplate.getGenre(), movie.getGenre())) {
                            error = "el genero";
                            moviesByTemplate.add(movie);
                        }
                        //Finalmente comprobamos la duracion o los minutos que tiene la pelicula, aqui deberia lanzar una excepcion pero ya me ocupare de eso
                        else if (movieTemplate.getMinutes() != null) {
                            error = "la duración";
                            if (movieTemplate.getMinutes() < 0) {
                                throw new IllegalArgumentException("Los minutos no pueden ser un número negativo");
                            } else if (movieTemplate.getMinutes() >= movie.getMinutes()) {
                                moviesByTemplate.add(movie);
                            }
                        }
                        break;
                    case 2:
                        //Primero la convinacion nombre genero
                        if (movieTemplate.getName() != null && movieTemplate.getGenre() != null) {
                            error = "el nombre y el genero";
                            //Ahora comprobamos el nombre y el genero
                            if (movie.getName().toLowerCase().contains(movieTemplate.getName().toLowerCase())
                                    && Objects.equals(movieTemplate.getGenre(), movie.getGenre())) {
                                moviesByTemplate.add(movie);
                            }
                        }
                        //Ahora el Nombre y la duracion
                        else if (movieTemplate.getName() != null && movieTemplate.getMinutes() != null) {
                            //Aqui comprobamos el nombre
                            if (movie.getName().toLowerCase().contains(movieTemplate.getName().toLowerCase())) {
                                //Aqui la excepcion de illegal Argument
                                if (movieTemplate.getMinutes() < 0) {
                                    throw new IllegalArgumentException("Los minutos no pueden ser un número negativo");
                                    //Y acá los minutos
                                } else if (movieTemplate.getMinutes() >= movie.getMinutes()) {
                                    moviesByTemplate.add(movie);
                                }
                            }
                        }
                        //Ahora el genero y los minutos
                        else if (movieTemplate.getGenre() != null && movieTemplate.getMinutes() != null) {
                            //Aca comprobamos el genero
                            if (Objects.equals(movieTemplate.getGenre(), movie.getGenre())) {
                                //Aqui la excepcion de illegal Argument
                                if (movieTemplate.getMinutes() < 0) {
                                    throw new IllegalArgumentException("Los minutos no pueden ser un número negativo");
                                    //Y acá los minutos
                                } else if (movieTemplate.getMinutes() >= movie.getMinutes()) {
                                    moviesByTemplate.add(movie);
                                }
                            }
                        }
                        break;
                    //Ahora lo haremos con los tres atributos, nombre, genero y minutos
                    case 3:
                        //Primero el nombre y el genero
                        if (movie.getName().toLowerCase().contains(movieTemplate.getName().toLowerCase())
                                && Objects.equals(movieTemplate.getGenre(), movie.getGenre())) {
                            //Y ahora los minutos
                            if (movieTemplate.getMinutes() < 0) {
                                throw new IllegalArgumentException("Los minutos no pueden ser un número negativo");
                                //Y acá los minutos
                            } else if (movieTemplate.getMinutes() >= movie.getMinutes()) {
                                moviesByTemplate.add(movie);
                            }
                        }
                        break;
                }
            }
        }
        return moviesByTemplate;
    }

Asi quedaron mis pruebas

/*-----------------Pruebas con un solo atributo-----------------*/

    @Test
    public void get_movie_by_template_when_id_is_not_null() {
        Movie movie = new Movie(6, null, null, null);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(List.of(6)));
    }

    @Test
    public void get_movie_by_template_only_with_name() {
        Movie movie = new Movie(null, "super", null, null);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(1, 3, 4, 6)));
    }

    @Test
    public void get_movie_by_template_only_with_minutes() {
        Movie movie = new Movie(null, null, 112, null);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(4, 5, 6)));
    }

    @Test
    public void get_movie_by_template_only_with_genre() {
        Movie movie = new Movie(null, null, null, Genre.THRILLER);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(2, 4)));
    }

/*-----------------Pruebas con dos atributos-----------------*/

    @Test
    public void get_movie_by_template_with_name_and_genre() {
        Movie movie = new Movie(null, "e", null, Genre.THRILLER);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(2, 4)));
    }

    @Test
    public void get_movie_by_template_with_name_and_minutes() {
        Movie movie = new Movie(null, "er", 152, null);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(1, 3, 4, 6)));
    }

    @Test
    public void get_movie_by_template_with_genre_and_minutes() {
        Movie movie = new Movie(null, null, 119, Genre.COMEDY);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(Arrays.asList(3, 6)));
    }

/*-----------------Pruebas con los tres atributos-----------------*/

    @Test
    public void get_movie_by_template_with_name_minutes_and_genre() {
        Movie movie = new Movie(null, "Super 8", 112, Genre.THRILLER);

        Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);

        List<Integer> moviesids = getIntegers(moviesGetted);

        assertThat(moviesids, CoreMatchers.is(List.of(4)));
    }

/*-----------------Pruebas cuando se den minutos negativos-----------------*/

    @Test
    public void get_movie_by_template_with_negative_minutes_with_assertThrows() {
        Movie movie = new Movie(null, null, -1, null);

        assertThrows(IllegalArgumentException.class, () -> {
            Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);
        });
    }

    @Test
    public void get_movie_by_template_with_negative_minutes_with_asserEquals() {
        Movie movie = new Movie(null, null, -1, null);

        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
            Collection<Movie> moviesGetted = movieService.findMovieByTemplate(movie);
        });

        assertEquals("Los minutos no pueden ser un número negativo", exception.getMessage());
    }



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

Y este es el resultado

Me eh quedado ah gusto y esto lo usare en un proyecto que madre mia, me viene de perlas para buscar usuarios por nombre, id, rango o distintas convinaciones, esto sera genial jaja Gracias Platzi, nunca me creí capaz de algo tan genial pero ahora solo veo que esto es genial pero el limite es el cielo jaja

Fernando Sanchez Chavez

Los ejemplos que se vieron en el curso https://github.com/Fernando-dev-git/Curso-Junit-Basico-Movies

Diego Portillo

//MovieServiceShould.java
@Test
    public void return_movies_by_name_and_length(){
        assertThat(getMovieIds(movieService.findMoviesByTemplate(new Movie("M", 112, null, null))), CoreMatchers.is(Arrays.asList(5,6)));
    }
    @Test
    public void return_movies_by_name_genre_and_length(){
        assertThat(getMovieIds(movieService.findMoviesByTemplate(new Movie("M", 112, Genre.HORROR, null))), CoreMatchers.is(Arrays.asList(5)));
    }
    @Test
    public void return_movies_by_director_with_template(){
        assertThat(getMovieIds(movieService.findMoviesByTemplate(new Movie(null, null, null, "nol"))), CoreMatchers.is(Arrays.asList(1,2)));
    }
    @Test
    public void return_movies_by_id_with_template(){
        assertThat(getMovieIds(movieService.findMoviesByTemplate(new Movie(1,"z", null, null, "nol"))), CoreMatchers.is(Arrays.asList(1)));
    }
    @Test(expected = IllegalArgumentException.class)
    public void return_illegal_argument_exception_if_minutes_are_negative(){
        movieService.findMoviesByTemplate(new Movie(1,"z", -11, null, "nol"));
    }
//MovieService.java
    public Collection<Movie> findMoviesByTemplate(Movie template) {

        Stream<Movie> movies = movieRepository.findAll().stream();
        if (template.getMinutes() < 0){
            throw new IllegalArgumentException();
        }
        else if(template.getId() != null){
            return movies.filter(movie -> Objects.equals(movie.getId(), template.getId())).collect(Collectors.toList());
        }
        else {
            if (template.getDirector() != null) {
                movies = movies.filter(movie -> movie.getDirector().toLowerCase().contains(template.getDirector().toLowerCase()));
            }
            if (template.getMinutes() != null) {
                movies = movies.filter(movie -> movie.getMinutes() <= template.getMinutes());
            }
            if (template.getName() != null) {
                movies = movies.filter(movie -> movie.getName().toLowerCase().contains(template.getName().toLowerCase()));
            }
            if (template.getGenre() != null) {
                movies = movies.filter(movie -> movie.getGenre().equals(template.getGenre()));
            }
            return movies.collect(Collectors.toList());
        }
    }

Argenis Rodríguez

package dev.arsystem.util;

import java.util.function.Predicate;

public class PredicateUtil {
	public static <T> Predicate<T> addPredicate(Predicate<T> initialPredicate, Predicate<T> added) {
		if (initialPredicate == null)
			return added;
		return initialPredicate.and(added);
	}
}

private Collection<Movie> findMoviesByFilter(Predicate<Movie> predicate) {
		return repository.getAll()
				.stream()
				.filter(predicate)
				.collect(Collectors.toList());
	}
	
	public Collection<Movie> findMoviesByTemplate(Movie movie) {
		if (movie.getId() != null)
			return findMoviesByFilter(mov -> mov.getId() == movie.getId());
		
		Predicate<Movie> predicate = null;
		
		if (movie.getMinutes() != null && movie.getMinutes().compareTo(0) < 0)
			throw new IllegalArgumentException("Los minutos no deben ser negativos");
		else if (movie.getMinutes() != null)
			predicate = PredicateUtil.addPredicate(predicate, mov -> mov.getMinutes().compareTo(movie.getMinutes()) < 0);
		
		if (movie.getName() != null)
			predicate = PredicateUtil.addPredicate(predicate
					, mov -> mov.getName().toUpperCase().contains(movie.getName().toUpperCase()));
		
		if (movie.getGenre() != null)
			predicate = PredicateUtil.addPredicate(predicate, mov -> mov.getGenre() == movie.getGenre());
		
		if (movie.getDirector() != null)
			predicate = PredicateUtil.addPredicate(predicate
					, mov -> mov.getDirector().toUpperCase().contains(movie.getDirector().toUpperCase()));
		
		return findMoviesByFilter(predicate);
	}

package dev.arsystem.test;

import static org.junit.Assert.*;

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

import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

import dev.arsystem.movies.data.MovieRepository;
import dev.arsystem.movies.entity.Genre;
import dev.arsystem.movies.entity.Movie;
import dev.arsystem.movies.service.MovieService;

public class MovieServiceTemplateTest {
	
	@Before
	public void setUp() throws Exception {
		MovieRepository repository = Mockito.mock(MovieRepository.class);
		
		Mockito.when(repository.getAll())
			.thenReturn(Arrays.asList(
				new Movie(1, Genre.ACTION, "Avengers", 120, "Joss Whedon")
				, new Movie(2, Genre.HORROR, "Scream", 135, "Director 1")
				, new Movie(3, Genre.THRILLER, "Memento", 136, "Director 2")
				, new Movie(4, Genre.COMEDY, "There's Someting About Mary", 110, "Josh 2")
				, new Movie(5, Genre.HORROR, "Last Night", 156, "Horror Director")
				, new Movie(6, Genre.ACTION, "Matrix", 158, "John Wick :)")
				, new Movie(7, Genre.ACTION, "Matrix Recargado", 136, "John Wick :)")
				, new Movie(8, Genre.ACTION, "Avengers Age of Ultron", 168, "Avengers Director")
				, new Movie(9, Genre.HORROR, "Scream Part II", 135, "Director 2")
				, new Movie(10, Genre.HORROR, "Last Night Part II", 156, "Horror Director"))
			);
		
		service = new MovieService(repository);
	}
	
	@Test
	public void testByGenreAndDuration() {
		assertEquals(Arrays.asList(1, 7)
				, getMoviesIds(service.findMoviesByTemplate(new Movie(Genre.ACTION, null, 150, null))));
	}
	
	@Test
	public void testById() {
		assertEquals(Arrays.asList(2)
				, getMoviesIds(service.findMoviesByTemplate(new Movie(2, Genre.HORROR, "Scream", 135, "Director 1"))));
	}
	
	@Test
	public void testByDurationAndName() {
		assertEquals(Arrays.asList(1)
				, getMoviesIds(service.findMoviesByTemplate(new Movie(null, "aven", 150, null))));
	}
	
	@Test
	public void testByDirectorGenderAndDuration() {
		assertEquals(Arrays.asList(1, 7)
				, getMoviesIds(service.findMoviesByTemplate(new Movie(null, Genre.ACTION, null, 150, "jo"))));
	}
	
	@Test(expected = IllegalArgumentException.class)
	public void testByNegativeDuration() {
		service.findMoviesByTemplate(new Movie(null, Genre.ACTION, null, -1, "jo"));
	}
	
	private static Collection<Integer> getMoviesIds(Collection<Movie> movies) {
		return movies.stream()
				.map(Movie::getId)
				.collect(Collectors.toList());
	}
	
	private MovieService service;
}

Adrian De Los Reyes

Dejo el metodo de Service: Muchos if pero se entiende

   public Collection<Movie> findMoviesByTemplate(Movie template) {
        Collection<Movie> movies = new ArrayList<>();

        if(template.getId() != null){
            Collection<Movie> moviesId = findMoviesById(template.getId());
            movies.addAll(moviesId);
            return movies;
        }

        if(template.getName() != null){
            Collection<Movie> moviesId = findByName(template.getName());
            movies.addAll(moviesId);
        }

        if(template.getMinutes() != null) {
            if (template.getMinutes() < 0) {
                throw new IllegalArgumentException();
            }
            Collection<Movie> moviesId = findMoviesByLength(template.getMinutes());
            movies.addAll(moviesId);
        }
        if(template.getGenre() != null){
            Collection<Movie> moviesId = findMoviesByGenre(template.getGenre());
            movies.addAll(moviesId);
        }

        if(template.getDirector() != null){
            Collection<Movie> moviesId = findByDirector(template.getDirector());
            movies.addAll(moviesId);
        }

        return movies;
    }

Bairon Gudiño

En mi solución creé un método para consultar en la BDD según los datos del template.

Nuevo método en MovieRepositoryJdbc

    @Override
    public Collection<Movie> findByTemplate(Movie template) {

        String and = "";
        List<Object> argsList = new ArrayList<>();
        StringBuilder sql =  new StringBuilder();
        sql.append("select * from movies where ");

        if (template.getMinutes() != null) {
           sql.append(" minutes <=  ? ");
           argsList.add(template.getMinutes());
            and = " and ";
        }

        if (StringUtil.isNotEmpty(template.getName())) {
           sql.append(and).append("  name like  ? ");
            argsList.add("%"+template.getName()+"%");
            and = " and ";
        }

        if(template.getGenre() != null) {
            sql.append(and).append("  genre =  ? ");
            argsList.add(template.getGenre().toString());
            and = " and ";
        }

        if (StringUtil.isNotEmpty(template.getDirector())) {
            sql.append(and).append(" director like  ? ");
            argsList.add("%"+template.getDirector()+"%");
        }

        return jdbcTemplate.query(sql.toString(), argsList.stream().toArray(), movieMapper);
    }

En la clase MovieService valido el tiempo negativo para lanzar la excepcion o si se debe consultar por id o por template

  public Collection<Movie> findMoviesByTemplate(Movie template) throws IllegalArgumentException {

        if (template.getMinutes() != null && template.getMinutes().intValue() < 0) {
            throw new IllegalArgumentException("Time is negative");
        }

        if (template.getId() != null) {
           return Arrays.asList(findById(template.getId()));
        } else {
            return movieRepository.findByTemplate(template);
        }
    }

Nuevos test MovieRepositoryIntegrationTest con algunas combinaciones del template

    @Test
    public void findTemplateById() {
        Movie template = new Movie(5, "Scream", 111, Genre.HORROR, "Kevin Williamson and Wes Craven");
        Collection<Movie> movies = movieRepositoryJdbc.findByTemplate(template);
        Assert.assertThat(movies, is(Arrays.asList(template)));
    }

    @Test
    public void findTemplateByNameAndTime() {

        List<Movie> moviesList = Arrays.asList(
                new Movie(3, "There is Something about Mary", 119, Genre.COMEDY, "Peter Farrelly"),
                new Movie(7, "Matrix", 136, Genre.ACTION, "Lana and Lilly Wachowski")
        );

        Collection<Movie> movies = movieRepositoryJdbc.findByTemplate(new Movie(null, "MA", 140, null, null));
        Assert.assertThat(movies, is(moviesList));
    }

    @Test
    public void findTemplateByNameAndGenre() {

        List<Movie> moviesList = Arrays.asList(
                new Movie(7, "Matrix", 136, Genre.ACTION, "Lana and Lilly Wachowski"),
                new Movie(8, "Batman vs Super Man", 151, Genre.ACTION, "Zack Snyder")
        );

        Collection<Movie> movies = movieRepositoryJdbc.findByTemplate(new Movie(null, "mA", null, Genre.ACTION, null));
        Assert.assertThat(movies, is(moviesList));
    }


    @Test
    public void findTemplateByTimeGenreAndDirector() {
        Collection<Movie> movies = movieRepositoryJdbc.findByTemplate(new Movie(null, 160, Genre.ACTION, "noLA"));
        assertThat(movies, is(Arrays.asList(
                new Movie(1, "Dark Knight", 152, Genre.ACTION, "Christopher Nolan")
        )));
    }

Nuevos test del MovieServiceTest

@Test(expected = IllegalArgumentException.class)
    public void findByTimeNegative() {
        movieService.findMoviesByTemplate(new Movie(1, "Dark Night", -152, Genre.ACTION, "Christopher Nolan"));
    }

    @Test
    public void findTemplateById() {
        Collection<Movie> movies = movieService.findMoviesByTemplate(new Movie(1, "Dark Night", 152, Genre.ACTION, "Christopher Nolan"));
        assertThat(getId(movies), is(Arrays.asList(1)));
    }

    @Test
    public void findTemplateByNameAndTime() {

        Movie template = new Movie(null, "MA", 140, null, null);
        List<Movie> moviesList = Arrays.asList(
                new Movie(3, "There is Something about Mary", 119, Genre.COMEDY, "Peter Farrelly"),
                new Movie(7, "Matrix", 136, Genre.ACTION, "Lana and Lilly Wachowski"));
        Mockito.when(movieRepository.findByTemplate(template)).thenReturn(moviesList);

        assertThat(getId(movieService.findMoviesByTemplate(template)), is(Arrays.asList(3,7)));
    }

    @Test
    public void findTemplateByNameAndGenre() {

        Movie template = new Movie(null, "supER", null, Genre.ACTION, null);
        List<Movie> moviesList = Arrays.asList(
                new Movie(4, "Super 8", 112, Genre.ACTION, "Jeffrey Jacob Abrams"),
                new Movie(8, "Batman vs Super Man", 151, Genre.ACTION, "Zack Snyder"));
        Mockito.when(movieRepository.findByTemplate(template)).thenReturn(moviesList);

        assertThat(getId(movieService.findMoviesByTemplate(template)), is(Arrays.asList(4,8)));
    }

    @Test
    public void findTemplateByTimeGenreAndDirector() {
        Movie template = new Movie(null, "supER", null, Genre.ACTION, null);
        List<Movie> moviesList = Arrays.asList(
                new Movie(1, "Dark Knight", 152, Genre.ACTION, "Christopher Nolan"));
        Mockito.when(movieRepository.findByTemplate(template)).thenReturn(moviesList);

        assertThat(getId(movieService.findMoviesByTemplate(template)), is(Arrays.asList(1)));
    }

También creé el método isNotEmpty en la clase StringUtil

   public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    public static boolean isEmpty(String str) {
        return str == null || str.trim().length() == 0;
    }

Y por último los datos de prueba del archivo test-data.sql

CREATE TABLE IF NOT EXISTS movies (
  id INT AUTO_INCREMENT PRIMARY KEY,
  name VARCHAR(50) NOT NULL,
  minutes INT NOT NULL,
  genre VARCHAR(50) NOT NULL,
  director VARCHAR(50) NOT NULL
);

insert into movies (name, minutes, genre, director) values
    ('Dark Knight', 152, 'ACTION', 'Christopher Nolan'),
    ('Memento', 113, 'THRILLER', 'Christopher Nolan'),
    ('There is Something about Mary', 119, 'COMEDY', 'Peter Farrelly'),
    ('Super 8', 112, 'THRILLER', 'Jeffrey Jacob Abrams'),
    ('Scream', 111, 'HORROR', 'Kevin Williamson and Wes Craven'),
    ('Home Alone', 102, 'COMEDY', 'Chris Columbus'),
    ('Matrix', 136, 'ACTION', 'Lana and Lilly Wachowski'),
    ('Batman vs Super Man', 151, 'ACTION', 'Zack Snyder');

Astrik Sem Torres Garcia

Mi solución, solo me falto agregar el IllegalArgumentException

public Collection<Movie> findByTemplate(Movie template) {
    Collection<Movie> leakedMovies = new ArrayList<Movie>();
    Collection<Movie> movies = new ArrayList<Movie>();

    Integer id = template.getId();
    String name = template.getName();
    Integer minutes = template.getMinutes();
    Genre genre = template.getGenre();

    if (id != null) return findById(id);

    if (name != null) {
        movies = findByName(name);
        for (Movie movie : movies) {
            if (minutes != null || genre != null) {
                if (minutes != null) {
                    if (movie.getMinutes() <= minutes)
                        leakedMovies.add(movie);
                }
                if (genre != null) {
                    if (genre == movie.getGenre())
                        leakedMovies.add(movie);
                }
            } else leakedMovies.add(movie);
        }
    } else if (minutes != null) {
        movies = findMoviesByLength(minutes);
        for (Movie movie : movies) {
            if (genre != null) {
                if (genre == movie.getGenre())
                    leakedMovies.add(movie);
            }
            else leakedMovies.add(movie);
        }
    } else if (genre != null) {
        movies = findMoviesByGenre(genre);
        leakedMovies.addAll(movies);
    }
    
    return leakedMovies;
}

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