No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Básico de Testing en Java

Curso Básico de Testing en Java

Ferran Maylinch Carrasco

Ferran Maylinch Carrasco

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

18/24
Recursos

Aportes 19

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Este profesor explica MUY bien

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

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

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

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

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

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

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

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


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

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


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

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

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


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

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


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

        return getId;
    }
}

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

Este curso envejece muy bien.
El profesor explica muy bien

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

package com.softin.movies.service;

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

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

import static org.junit.Assert.assertTrue;

public class MovieServiceShould {

    private MovieService movieService;

    @Before
    public void setUp() throws Exception {

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

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

        movieService = new MovieService(movieRepository);
    }

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

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

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

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

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

MovieService.java

public Collection<Movie> findByName(String initialLetterName) {

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

MovieService.test

@Test
    public void return_movies_by_first_letter_name() {

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

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

    }

Este IDE es maravilloso! Ahorra mucho tiempo con los atajos

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

class MovieServiceShould {

    private MovieService movieService;

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

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

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

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

        moviesByLength.forEach(movie -> assertTrue(movie.getMinutes() <= 119));
    }
}
Por si a alguien le llega a fallar, este está hecho con lo más actualizado, ***2024 26 de enero*** Recuerden que AssertJ requiere agregarlo en el pom ```html <dependency> <groupId>org.assertj</groupId> <artifactId>assertj-core</artifactId> <version>3.25.2</version> </dependency> ``` ```java package movies.service; import static org.assertj.core.api.Assertions.assertThat; import java.util.*; import java.util.stream.Collectors; import org.junit.jupiter.api.*; import org.mockito.Mockito; import movies.data.IMovieRepository; import movies.model.*; public class MovieServiceTest { private static MovieService movieService; @BeforeAll public static void setup() throws Exception{ IMovieRepository movieRepository = Mockito.mock(IMovieRepository.class); Mockito.when(movieRepository.findAll()).thenReturn( Arrays.asList( new Movie(1, "Dark Knight", 152, Genre.ACTION), new Movie(2, "Memento", 113, Genre.THRILLER), new Movie(3, "There's Something About Marty", 119, Genre.COMEDY), new Movie(4, "Super 8", 112, Genre.THRILLER), new Movie(5, "Scream", 111, Genre.HORROR), new Movie(6, "Home Alone", 103, Genre.COMEDY), new Movie(7, "Matrix", 136, Genre.ACTION) ) ); movieService = new MovieService(movieRepository); } @Test public void return_movies_by_service(){ Collection<Movie> movies = movieService.findMoviesByGenre(Genre.COMEDY); List<Integer> movieIds = getMovieIds(movies); assertThat(movieIds).containsExactlyInAnyOrder(3, 6); } @Test public void return_movies_by_length(){ Collection<Movie> movies = movieService.findMoviesByLength(119); List<Integer> movieIds = getMovieIds(movies); assertThat(movieIds).containsExactlyInAnyOrder(2,3,4,5,6); } private List<Integer> getMovieIds(Collection<Movie> movies) { return movies.stream().map(Movie::getId).collect(Collectors.toList()); } } ```

Gracias profesor!

Agradecido de todo el aprendizaje recibido 🎉

un mejor metodo de busqueda

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

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

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

Magnifico

Genial muchas gracias 😃

Test By Name and Id