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

Clase 21 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

Queremos implementar nuevas opciones de búsqueda en nuestra aplicación de películas.

Buscar películas por nombre

En nuestra aplicación de películas queremos poder buscar películas por nombre.

Implementa la función findByName en MovieService, y añade un test para probar que funciona correctamente. Ten en cuenta que queremos que esta función encuentre películas que contengan una parte del nombre indicado, así que si buscamos “Super” queremos obtener películas como “Super 8” o “Superman”.

Pista: puedes usar la función contains.

Si es necesario, añade más películas en el test, para que hayan películas que contengan las mismas palabras.

Trata de que la función devuelva las películas aunque busquemos “super” en minúsculas.

Pista: puedes usar la función toLowerCase.

Reto extra: Buscar películas por director

También queremos añadir el director de las películas y poder buscarlas por director.

Añade el atributo director en la clase Movie. Tendrás que añadirlo también en los constructores de Movie, y actualizar los tests para indicar este dato. Puedes poner nombres de directores inventados si no quieres buscar los nombres reales (p.ej. “director1”, “director2”, etc). En los tests no importa que los datos sean inventados.

Una vez hayas añadido el atributo director, implementa la función findByDirector en MovieService, y añade un test para probar que funciona correctamente. Puedes usar la misma técnica que en findByName, y dejar buscar por una parte del nombre del director.

David Gallego

student•

// MovieRepositoryJdbc.java
@Override
public Collection<Movie> findByName(String name) {
	Collection<Movie> allMovies = jdbcTemplate.query("select * from movies", movieMapper);

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

	for(Movie movie : allMovies) {
		if(movie.getName().toLowerCase().contains(name.toLowerCase())) {
			moviesFound.add(movie);
		}
	}

	return moviesFound;
}

// MovieRepositoryIntegrationTest.java
@Test
public void loadMoviesByName() {
	// 1. Insert Movie into DB
	Collection<Movie> moviesAdded = Arrays.asList(
		new Movie(4, "Super 8", 112, Genre.THRILLER),
		new Movie(5, "Superman", 95, Genre.ACTION),
		new Movie(6, "Superior", 123, Genre.COMEDY)
	);

	moviesAdded.stream().forEach(movie -> movieRepository.saveOrUpdate(movie));

	// 2. Find movie by name
	Collection<Movie> moviesFound = movieRepository.findByName("Super");
	assertThat(moviesFound, is(moviesAdded));
}

Cesar David Ramírez Dimaté

Es importante resaltar, que estás mezclando lógica que se encuentra de MovieRepository con MovieRepositoryJdbc.

El código que puedes implementar para el método findByName es el siguiente:

@Override
public Collection<Movie> findByName(String name) {
  String[] args = {"%" + name.toLowerCase() + "%"};
  return jdbcTemplate.query("SELECT * FROM movies WHERE LOWER(name) LIKE ?", args, movieMapper);
}

Cristian Ortega

Agregar en la clase Movie el campo director como un string, tanto en los constructores, añadiendo sus métodos get a set.

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

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

// Clase MovieServiceShould
@Test
    public void returnMovieByName(){
        Collection<Movie> movies = movieService.findMoviesByName("matrix");
        assertThat(getMovieIds(movies), is(Arrays.asList(7, 9, 10)));
    }

    @Test
    public void returnMovieByDirector(){
        Collection<Movie> movies = movieService.findMoviesByDirector("nolan");
        assertThat(getMovieIds(movies), is(Arrays.asList(1, 2, 8)));
    }

Importante: Agregar 3 nuevas películas en el setup junto a sus directores. Para eso dejo el código.

@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, "Hermanas Wachowski"),
                        new Movie(8, "Dark Knight Rises", 152, Genre.ACTION, "Christopher Nolan"),
                        new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),
                        new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")
                ));
        movieService = new MovieService(movieRepository);
    }

Antonio Madrid

He corregido el método findByName() para que acepte cualquier tipo de String sin importar mayúsculas o minúsculas.

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

Juan Camilo Cubillos Diaz

Comparto mi solucion con consultas SQL y método java con lambdas, La opcion de SQL optiene los datos de manera mas rapida.

    @Test
    public void load_movie_by_name() {
        Collection<Movie> movies = movieRepository.findByName("dark");
        assertThat(movies, CoreMatchers.is(Arrays.asList(
                new Movie(1, "Dark Knight", 152, Genre.ACTION,"Mell Gibson"),
                new Movie(4, "Dark Phoenix", 190, Genre.COMEDY, "Tobias Pacheco"),
                new Movie(5, "Dark Moon", 100, Genre.THRILLER, "Camilo Cubillos"))));
    }

    @Test
    public void load_movie_by_second_way() {
        Collection<Movie> movies = movieRepository.findByName("dark");
        assertThat(movies, CoreMatchers.is(Arrays.asList(
                new Movie(1, "Dark Knight", 152, Genre.ACTION,"Mell Gibson"),
                new Movie(4, "Dark Phoenix", 190, Genre.COMEDY, "Tobias Pacheco"),
                new Movie(5, "Dark Moon", 100, Genre.THRILLER, "Camilo Cubillos"))));
    }

    @Test
    public void load_movie_by_director() {
        Collection<Movie> movies = movieRepository.findByDirector("Camilo Cubillos");
        assertThat(movies, CoreMatchers.is(Arrays.asList(
                new Movie(3, "Matrix", 136, Genre.ACTION,"Camilo Cubillos"),
                new Movie(5, "Dark Moon", 100, Genre.THRILLER, "Camilo Cubillos"))));
    }

Clase MovieRepositoryJdbc

    @Override
    public Collection<Movie> findByName(String name) {
        name = name.toLowerCase();
        return jdbcTemplate.query("SELECT * FROM MOVIES WHERE LOWER(name) LIKE '%" + name + "%'", movieMapper);
    }

    @Override
    public Collection<Movie> findByNameOtherWay(String name) {
        return findAll().stream()
                .filter(movie -> movie.getName().toLowerCase().contains(name.toLowerCase()))
                .collect(Collectors.toList());
    }

    @Override
    public Collection<Movie> findByDirector(String name) {
        name = name.toLowerCase();
        return jdbcTemplate.query("SELECT * FROM MOVIES WHERE LOWER(director) LIKE '%" + name + "%'", movieMapper);
    }

Julio Cesar Jimenez Garcia

@Test

publicvoid load_movies_by_name() {
    Collection<Movie> searchedMovies = movieRepositoryJdbc.findByName("super");
    assertThat(searchedMovies, CoreMatchers.is(Arrays.asList(

        new Movie (4, "Superman", 111, Genre.ACTION),
        new Movie (5, "Super 8", 110, Genre.DRAMA),
        new Movie (6, "Super PAPA", 123, Genre.COMEDY)
    )));
}


@Override
public Collection<Movie> findByName(String name) {
    returnfindAll().stream()
            .filter(movie -> movie.getName().toLowerCase().contains(name.toLowerCase()))
            .collect(Collectors.toList());
}

Jaime Andres Quiñones Chacón

Agregando el método que nos permite buscar las peliculas por el nombre:

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

El test asociado a esa función del movieService:

  @Test
    public void shouldReturnMoviesByName() {
        Collection<Movie> movies = this.movieService.findMoviesByName("Super");

        Assert.assertEquals(Arrays.asList(4,8,9), getMoviesIds(movies));
    }

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

Santiago López

Jdbc repository:

    @Override
    public Collection<Movie> findByName(String name) {
        name = name.toLowerCase();
        return jdbcTemplate.query("select * from movies where lower(name) like ?", movieMapper,"%" + name + "%");
    }

Test:

    @Test
    public void searchMovieByName() {
        Collection<Movie> movies = movieRepository.findByName("Super");

        assertEquals(movies, Arrays.asList(
                new Movie(4, "Superman", 143, Genre.ACTION),
                new Movie(5, "Super 8", 112, Genre.THRILLER)
        ));

    }

ESTIBEN COY

Buen codigo

William Beltran

// MovieRepositoryJdbc.java
@Override
public Collection<Movie> findByName(String name) {
	 String[] args = {"%" + name.toLowerCase() + "%"};
  return jdbcTemplate.query("SELECT * FROM movies WHERE LOWER(name) LIKE ?", args, movieMapper);
}

@Override
public Collection<Movie> findByDirector(String director) {
	 String[] args = {"%" + director.toLowerCase() + "%"};
  return jdbcTemplate.query("SELECT * FROM movies WHERE LOWER(director) LIKE ?", args, movieMapper);
}

// MovieRepositoryIntegrationTest.java

@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, "Hermanas Wachowski"),
					new Movie(8, "Dark Knight Rises", 152, Genre.ACTION, "Christopher Nolan"),
					new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),
					new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")
			));
	movieService = new MovieService(movieRepository);
}
	
@Test
public void loadMoviesByName() {
	//Find movie by name
	Collection<Movie> moviesFound = movieService.findByName("Super");
	assertThat(moviesFound, is(Arrays.asList(
		new Movie(4, "Super 8", 112, Genre.THRILLER, "J. J. Abrams")
	)));
	
	@Test
public void loadMoviesByDirector() {
	//Find movie by name
	Collection<Movie> moviesFound = movieService.findByDirector("Hermanas Wachowski");
	assertThat(moviesFound, is(Arrays.asList(
					new Movie(7, "Matrix", 136, Genre.ACTION, "Hermanas Wachowski"),
					new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),
					new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")
	)));
}
```// MovieRepositoryJdbc.java

@Override

public Collection\<Movie> findByName(String name) {

&#x9; String\[] args = {"%" + name.toLowerCase() + "%"};

&#x20; return jdbcTemplate.query("SELECT \* FROM movies WHERE LOWER(name) LIKE ?", args, movieMapper);

}



@Override

public Collection\<Movie> findByDirector(String director) {

&#x9; String\[] args = {"%" + director.toLowerCase() + "%"};

&#x20; return jdbcTemplate.query("SELECT \* FROM movies WHERE LOWER(director) LIKE ?", args, movieMapper);

}



// MovieRepositoryIntegrationTest.java



@Before

public void setup() throws Exception{

&#x9;MovieRepository movieRepository = Mockito.mock(MovieRepository.class);

&#x9;Mockito.when(movieRepository.findAll()).thenReturn(

&#x9;		Arrays.asList(

&#x9;				new Movie(1, "Dark Knight", 152, Genre.ACTION, "Christopher Nolan"),

&#x9;				new Movie(2, "Memento", 113, Genre.THRILLER, "Christopher Nolan"),

&#x9;				new Movie(3, "There's Something About Mary", 119, Genre.COMEDY, "Peter Farrelly, Bobby Farrelly"),

&#x9;				new Movie(4, "Super 8", 112, Genre.THRILLER, "J. J. Abrams"),

&#x9;				new Movie(5, "Scream", 111, Genre.HORROR, "Wes Craven"),

&#x9;				new Movie(6, "Home Alone", 103, Genre.COMEDY, "Chris Columbus, Raja Gosnell, Peter Hewitt, Rod Daniel"),

&#x9;				new Movie(7, "Matrix", 136, Genre.ACTION, "Hermanas Wachowski"),

&#x9;				new Movie(8, "Dark Knight Rises", 152, Genre.ACTION, "Christopher Nolan"),

&#x9;				new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),

&#x9;				new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")

&#x9;		));

&#x9;movieService = new MovieService(movieRepository);

}

&#x9;

@Test

public void loadMoviesByName() {

&#x9;//Find movie by name

&#x9;Collection\<Movie> moviesFound = movieService.findByName("Super");

&#x9;assertThat(moviesFound, is(Arrays.asList(

&#x9;	new Movie(4, "Super 8", 112, Genre.THRILLER, "J. J. Abrams")

&#x9;)));

&#x9;

&#x9;@Test

public void loadMoviesByDirector() {

&#x9;//Find movie by name

&#x9;Collection\<Movie> moviesFound = movieService.findByDirector("Hermanas Wachowski");

&#x9;assertThat(moviesFound, is(Arrays.asList(

&#x9;				new Movie(7, "Matrix", 136, Genre.ACTION, "Hermanas Wachowski"),

&#x9;				new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),

&#x9;				new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")

&#x9;)));

}

// MovieRepositoryJdbc.java

@Override

public Collection<Movie> findByName(String name) {

String[] args = {"%" + name.toLowerCase() + "%"};

return jdbcTemplate.query("SELECT * FROM movies WHERE LOWER(name) LIKE ?", args, movieMapper);

}

public Collection<Movie> findByDirector(String director) {

String[] args = {"%" + director.toLowerCase() + "%"};

return jdbcTemplate.query("SELECT * FROM movies WHERE LOWER(director) LIKE ?", args, movieMapper);

// MovieRepositoryIntegrationTest.java

@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, "Hermanas Wachowski"),

new Movie(8, "Dark Knight Rises", 152, Genre.ACTION, "Christopher Nolan"),

new Movie(9, "The Matrix Reloaded", 136, Genre.ACTION, "Hermanas Wachowski"),

new Movie(10, "The Matrix Revolutions", 136, Genre.ACTION, "Hermanas Wachowski")

));

movieService = new MovieService(movieRepository);

public void loadMoviesByName() {

//Find movie by name

Collection<Movie> moviesFound = movieService.findByName("Super");

assertThat(moviesFound, is(Arrays.asList(

new Movie(4, "Super 8", 112, Genre.THRILLER, "J. J. Abrams")

)));

public void loadMoviesByDirector() {

Collection<Movie> moviesFound = movieService.findByDirector("Hermanas Wachowski");

Gabriel Omar Gramajo

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", "Christopher Nolan", 152, Genre.ACTION),
                        new Movie(2, "Memento", "Christopher Nolan", 113, Genre.THRILLER),
                        new Movie(3, "There's Something About Marty", "Peter Farrelly", 119, Genre.COMEDY),
                        new Movie(4, "Super 8", "J. J. Abrams", 112, Genre.THRILLER),
                        new Movie(5, "Scream", "Wes Craven", 111, Genre.HORROR),
                        new Movie(6, "Home Alone", "Chris Columbus", 103, Genre.COMEDY),
                        new Movie(7, "Matrix", "The Wachowskis", 136, Genre.ACTION),
                        new Movie(8, "Superman Returns", "Bryan Singer", 154, Genre.ACTION),
                        new Movie(9, "Spider-Man: Far from Home", "Jon Watts", 129, Genre.ACTION)
                )
        );

        movieService = new MovieService(movieRepository);
    }

    @Test
    public void return_movies_by_genre() {

        Collection<Movie> movies = movieService.findMoviesByGenre(Genre.COMEDY);

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


    @Test
    public void return_movies_by_lentgh() {

        Collection<Movie> movies = movieService.findMoviesByLength(119);

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

    @Test
    public void return_movie_by_name() {
        Collection<Movie> movies = movieService.findMovieByName("Super");

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

    @Test
    public void return_movie_by_name_lower_case() {
        Collection<Movie> movies = movieService.findMovieByName("home");

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

    @Test
    public void return_movie_by_name_upper_case() {
        Collection<Movie> movies = movieService.findMovieByName("HOME");

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

    @Test
    public void return_movie_by_director() {
        Collection<Movie> movies = movieService.findMovieByDirector("Christopher Nolan");

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

    private static List<Integer> getMovieIds(Collection<Movie> movies) {
        return movies.stream().map(Movie::getId).collect(Collectors.toList());
    }
}
``````js
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(int lentgh) {
        return movieRepository.findAll().stream()
                .filter(movie -> movie.getMinutes() <= lentgh).collect(Collectors.toList());
    }

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

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

eduardo montaño cardenas

 public Collection<Movie> findByName(String movieName) {
        if (movieName.trim().isEmpty()){
            throw new IllegalArgumentException("el nombre no puede ser vacio.");
        }
        return movieRepository.findAll().
                stream().
                filter(movie -> movie.getName().toLowerCase().contains(movieName.toLowerCase())).
                collect(Collectors.toList());
    }

 @Test
    public void should_return_movie_by_a_part_of_her_name() {
        Collection<Movie> moviesByName = movieService.findByName("SuPer");
        assertThat(getIds(moviesByName), is(Arrays.asList(4,8)));
    }

Luis Miguel Rodríguez

Metodo ( utilizando consulta SQL)

@Override
    public Collection<Movie> movieByName(String name) {
        return jdbcTemplate.query("SELECT * FROM MOVIES WHERE LOWER(name) LIKE '%" + name.toLowerCase() + "%'", movieMapper);
    }

Test

  @Test
    public void load_movie_by_name() {
        Collection<Movie> movies = movieRepository.movieByName("dark");

        assertThat(movies, CoreMatchers.is(Arrays.asList(
                new Movie(1, "Dark Knight", 152, Genre.ACTION)
                )));
    }

Engels Medina

// MovieRepository
    Collection<Movie> findByName(String nameSearch);

// MovieRepositoryJdbc
    @Override
    public Collection<Movie> findByName(String searchName) {
        Object[] args = { "%" + searchName + "%" };
        return jdbcTemplate.query("select * from movies where name like ?", args, movieMapper); //'%?%'
    }

// Add into Before method

        Mockito.when(repository.findByName("Evil")).thenReturn(
                Arrays.asList(
                        new Movie(6, "Evil Dead", 120, Genre.HORROR),
                        new Movie(7, "Resident Evil", 120, Genre.ACTION)
                )
        );


    @Test
    void returnMoviesByName() {
        Collection<Movie> movies = movieService.findByName("Evil");
        assertThat(getMovieIds(movies), CoreMatchers.is(Arrays.asList(6, 7)));
    }

joshua sainz

    @Test
    public void load_movies_by_name() {
        Collection<Movie> movies = mr.findByName("The");
        List<Integer> movieIds = getIntegers(movies);
        assertEquals(Arrays.asList(1, 2, 3, 4), movieIds);

    }

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

CRISTIAN OSORIO

Yo realicé el proceso utilizando la BD en memoria y no en MovieService

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

//MovieRepository
public interface MovieRepository {
    Movie findById(long id);
    Collection<Movie> findAll();
    Collection<Movie> findByName(String str);
    Collection<Movie> findByDirector (String dir);
    void saveOrUpdate(Movie movie);
}
//MovieReposiitoryJDBC
 @Override
    public Collection<Movie> findByName(String str) {
        return jdbcTemplate.query("select * from movies where LOWER(name) like '%" + str.toLowerCase() + "%'", movieMapper);
    }

    @Override
    public Collection<Movie> findByDirector (String dir) {
        return jdbcTemplate.query("select * from movies where LOWER(director) like '%" + dir.toLowerCase() + "%'", movieMapper);
    }

//Tests
@Test
    public void load_movie_by_name() throws SQLException {
        String str = "super";
        Movie movie1 = new Movie(4, "Super Mario", 152, Genre.COMEDY, "Super Mario Director");
        movieRepositoryJdbc.saveOrUpdate(movie1);
        Movie movie2 = new Movie(5, "SuperMan", 113, Genre.ACTION, "SuperMan Director");
        movieRepositoryJdbc.saveOrUpdate(movie2);
        Movie movie3 = new Movie(6, "Super algo", 136, Genre.THRILLER,"Super algo Director");
        movieRepositoryJdbc.saveOrUpdate(movie3);

        Collection<Movie> movies =  movieRepositoryJdbc.findByName(str);
        Collection<Movie> moviesFromDb =  Arrays.asList(
                new Movie(4, "Super Mario", 152, Genre.COMEDY, "Super Mario Director"),
                new Movie(5, "SuperMan", 113, Genre.ACTION, "SuperMan Director"),
                new Movie(6, "Super algo", 136, Genre.THRILLER,"Super algo Director"));

        assertEquals(moviesFromDb, movies);
    }

    @Test
    public void load_movie_by_director() throws SQLException {
        String dir = "director1";
        Movie movie1 = new Movie(4, "Super Mario", 152, Genre.COMEDY, "Super Mario Director1");
        movieRepositoryJdbc.saveOrUpdate(movie1);
        Movie movie2 = new Movie(5, "SuperMan", 113, Genre.ACTION, "SuperMan Director1");
        movieRepositoryJdbc.saveOrUpdate(movie2);
        Movie movie3 = new Movie(6, "Super algo", 136, Genre.THRILLER,"Super algo Director1");
        movieRepositoryJdbc.saveOrUpdate(movie3);

        Collection<Movie> movies =  movieRepositoryJdbc.findByDirector(dir);
        Collection<Movie> moviesFromDb =  Arrays.asList(
                new Movie(4, "Super Mario", 152, Genre.COMEDY, "Super Mario Director1"),
                new Movie(5, "SuperMan", 113, Genre.ACTION, "SuperMan Director1"),
                new Movie(6, "Super algo", 136, Genre.THRILLER,"Super algo Director1"));

        assertEquals(moviesFromDb, movies);
 }

Cristian Castro

La 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(int length) {
        return movieRepository.findAll().stream()
                .filter(movie -> movie.getMinutes() <= length).collect(Collectors.toList());
    }

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

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

Y la clase de test me quedó de la siguiente forma:

public class MovieServiceShould {

    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,"woody allen"),
                        new Movie(2,"Memento",113,Genre.THRILLER, "stanley kubrick"),
                        new Movie(3,"There's Something About Mary",119,Genre.COMEDY, "martin scorsese"),
                        new Movie(4,"Super 8",112,Genre.THRILLER, "agnes varda"),
                        new Movie(5,"superman",111,Genre.HORROR, "stanley kubrick"),
                        new Movie(6,"Home Alone",103,Genre.COMEDY, "martin scorsese"),
                        new Movie(7,"Matrix",136,Genre.ACTION, "stanley kubrick")
                )
        );
        movieService = new MovieService(movieRepository);
    }

    @Test
    public void return_movies_by_genre() {

        Collection<Movie> movies = movieService.findMoviesByGenre(Genre.COMEDY);

        assertThat(getMoviesIds(movies), CoreMatchers.is(Arrays.asList(3,6)));

    }

    @Test
    public void return_movies_by_length() {

        // Obtenemos la lista de peliculas a partir del método que vamos a testear
        Collection<Movie> movies = movieService.findMoviesByLength(119);

        assertThat(getMoviesIds(movies), CoreMatchers.is(Arrays.asList(2,3,4,5,6)));

    }

    @Test
    public void return_movies_by_name() {
        Collection<Movie> movies = movieService.findMoviesByName("SuPer");
        assertThat(getMoviesIds(movies), CoreMatchers.is(Arrays.asList(4,5)));

        Collection<Movie> movies2 = movieService.findMoviesByName("super");
        assertThat(getMoviesIds(movies2), CoreMatchers.is(Arrays.asList(4,5)));

        Collection<Movie> movies3 = movieService.findMoviesByName("SUPER");
        assertThat(getMoviesIds(movies3), CoreMatchers.is(Arrays.asList(4,5)));
    }

    @Test
    public void return_movies_by_director() {
        Collection<Movie> movies = movieService.findMoviesByDirector("stanley kubrick");
        assertThat(getMoviesIds(movies), CoreMatchers.is(Arrays.asList(2,5,7)));
    }

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

Juliette Alexandra Lopez Coy

@Test public void return_movies_with_director_julia(){ Collection<Movie> movies= movieService.findByDirector("julia"); assertThat(getMovieIds(movies), CoreMatchers. is(Arrays.asList(4,9)) ); }

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

@Test public void return_movies_with_name_super() { Collection<Movie> movies= movieService.findByName("super"); assertThat(getMovieIds(movies), CoreMatchers. is(Arrays.asList(4,8,9)) ); }

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

Diego Portillo

//Movie.java package com.platzi.javatests.movies.model;

import java.util.Objects;

public class Movie {

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

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

public Movie(Integer id, String name, int 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 int 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);
}

//MovieService.java package com.platzi.javatests.movies.service;

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

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

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(int length) {

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

//MovieServiceShould.java package com.platzi.javatests.movies.service;

import com.platzi.javatests.movies.data.MovieRepository; import com.platzi.javatests.movies.model.Genre; import com.platzi.javatests.movies.model.Movie; import org.hamcrest.CoreMatchers; 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.junit.Assert.*;

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, "Nolan"),
                    new Movie(2, "Memento", 113, Genre.THRILLER, "Nolan"),
                    new Movie(3, "There's Something About Mary", 119, Genre.COMEDY, "Fulano"),
                    new Movie(4, "Super 8", 112, Genre.THRILLER, "Mengano"),
                    new Movie(5, "Scream", 111, Genre.HORROR, "Sultano"),
                    new Movie(6, "Home Alone", 103, Genre.COMEDY, "Juan"),
                    new Movie(7, "Matrix", 136, Genre.ACTION, "Jose")
            )
    );

    movieService = new MovieService(movieRepository);
}

@Test
public void return_movies_by_genre() {

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

@Test
public void return_movies_by_length() {

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

@Test
public void return_movies_by_name(){
    Collection<Movie> movies = movieService.findMoviesByName("m");
    assertThat(getMovieIds(movies), CoreMatchers.is(Arrays.asList(2, 3, 5, 6 ,7)));
}
@Test
public void return_movies_by_director(){
    Collection<Movie> movies = movieService.findMoviesByDirector("n");
    assertThat(getMovieIds(movies), CoreMatchers.is(Arrays.asList(1, 2, 3, 4, 5, 6)));
}

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

Gabriel Antonio Macavilca Almanza

MovieService

public Collection<Movie> findMoviesByName(String name){

        return movieRepository.findAll().stream()
                .filter(movie -> movie.getName().toLowerCase().contains(name.toLowerCase())).collect(Collectors.toList());

    }

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

MovieServiceShould

@Test
    public void return_movies_by_name() {
        Collection<Movie> movies = movieService.findMoviesByName("Super");

        System.out.println(movies.stream().map(movie -> movie.getName()).collect(Collectors.toList()));

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

    @Test
    public void return_movies_by_director() {
        Collection<Movie> movies = movieService.findMoviesByDirector("2");

        System.out.println(movies.stream().map(movie -> movie.getDirector()).collect(Collectors.toList()));

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

Argenis Rodríguez

private Collection<Movie> findMoviesByFilter(Predicate<Movie> predicate) {
		return repository.getAll()
				.stream()
				.filter(predicate)
				.collect(Collectors.toList());
	}
	
	public Collection<Movie> findMoviesByName(String name) {
		return findMoviesByFilter(movie -> movie.getName().toUpperCase().contains(name.toUpperCase()));
	}
	
	public Collection<Movie> findMoviesByDirector(String director) {
		return findMoviesByFilter(movie -> movie.getDirector().toUpperCase().contains(director.toUpperCase()));
	}

package dev.arsystem.test;

import static org.junit.Assert.*;

import java.util.Arrays;

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 MovieServiceShould {
	
	@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", 136, "John Wick :)")
				, new Movie(7, Genre.ACTION, "Matrix Recargado", 136, "John Wick :)")
				, new Movie(8, Genre.ACTION, "Avengers Age of Ultron", 120, "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 testMovieByName() {
		assertEquals(Arrays.asList(
			new Movie(1, Genre.ACTION, "Avengers", 120, "Joss Whedon")
			, new Movie(8, Genre.ACTION, "Avengers Age of Ultron", 120, "Avengers Director"))
		, service.findMoviesByName("avengers"));
		
		assertEquals(Arrays.asList(
			new Movie(2, Genre.HORROR, "Scream", 135, "Director 1")
			, new Movie(9, Genre.HORROR, "Scream Part II", 135, "Director 2"))
		, service.findMoviesByName("scream"));
		
		assertEquals(Arrays.asList(
			new Movie(5, Genre.HORROR, "Last Night", 156, "Horror Director")
			, new Movie(10, Genre.HORROR, "Last Night Part II", 156, "Horror Director"))
		, service.findMoviesByName("night"));
	}
	
	@Test
	public void testMovieByDirector() {
		assertEquals(Arrays.asList(
			new Movie(2, Genre.HORROR, "Scream", 135, "Director 1")
			, new Movie(3, Genre.THRILLER, "Memento", 136, "Director 2")
			, new Movie(5, Genre.HORROR, "Last Night", 156, "Horror Director")
			, new Movie(8, Genre.ACTION, "Avengers Age of Ultron", 120, "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.findMoviesByDirector("director"));
		
		assertEquals(Arrays.asList(
			new Movie(1, Genre.ACTION, "Avengers", 120, "Joss Whedon")
			, new Movie(4, Genre.COMEDY, "There's Someting About Mary", 110, "Josh 2")
			, new Movie(6, Genre.ACTION, "Matrix", 136, "John Wick :)")
			, new Movie(7, Genre.ACTION, "Matrix Recargado", 136, "John Wick :)")
		), service.findMoviesByDirector("jo"));
	}
	
	private MovieService service;
}

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

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