Simulación de Clases en Java con Moquito

Clase 8 de 24 • Curso Básico de Testing en Java

Resumen

Mockito nos va a servir para simular clases mientras probamos, para añadirlo a nuestro proyecto debemos copiar las siguientes líneas de código:

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>2.23.4</version>
  <scope>test</scope>
</dependency>

Para instanciar un mock debemos utilizar la función Mockito.mock() e indicarle como parámetro la clase que va a simular. Las funciones assertFalse y assertTrue tal como su nombre lo indican, sirven para comprobar si un valor es igual a false o true respectivamente.

José Luis García Peceros

student•

<dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>2.23.4</version>
            <scope>test</scope>
        </dependency>

Elioenai Garcia

student•

Por con esta versión si funciona y en las recientes no para java 8? 🥸

Ferran Maylinch

teacher•

Perder sería "lose", no "loose". Sorry! 😅

Luzdelia Alba

student•

La dependencia que a mí me funcionó fue:

<dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>2.25.1</version>
            <scope>test</scope>
</dependency>

Juan Manuel Alberto Martin

student•

Otra alternativa es usando anotaciones para los mocks :)

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class PaymentProcessorTest {

        @Mock
        PaymentGateway paymentGateway;
        @InjectMocks
        private PaymentProcessor paymentProcessor;

        @Test
        public void payment_is_correct() {

            Mockito.when(paymentGateway.requestPayment(Mockito.any()))
                    .thenReturn(new PaymentResponse(PaymentResponse.PaymentStatus.OK));

            assertTrue(paymentProcessor.makePayment(1000));
        }

        @Test
        public void payment_is_wrong() {

            Mockito.when(paymentGateway.requestPayment(Mockito.any()))
                    .thenReturn(new PaymentResponse(PaymentResponse.PaymentStatus.ERROR));

            assertFalse(paymentProcessor.makePayment(1000));
        }
}

Alexis Rodriguez Jimenez

student•

Muchas gracias, me entró una duda acerca del @spy. En muchas partes hablan de que es una mala practica, pero cómo podría hacer cuando un metodo llama otro método adentro para mockearlo?

Cesar David Ramírez Dimaté

student•

La forma de mockear un método sería crear un método private y dentro de él simules el comportamiento interno de ese método para tener un resultado específico y utilizar dicho resultado con when().thenReturn().

Si a lo que te refieres es hacer más test del método, por ejemplo probar el método play() de la clase Dice, tendrías que hacer pruebas unitarias para este método en DiceTest.

Sebastian Diaz

student•

Tambien tengo entendido que es una buena practicar usar mockito , ya que nuestros test deben ser capaces de ser ejecutados sin tener una dependencia de otras clases, esto tambien va muy de la mano con las buenas practicas que hemos tenido a la hora de construir nuestro codigo.

Si haces un test que se empieza a complicar por que necesitas y dependes de muchas cosas, podrias replantear esa clases y desacoplarla de tal modo que esa clase haga una sola cosa y la haga bien.

Cesar David Ramírez Dimaté

student•

De hecho la razón de usar Mockito es simular nuestras clases con datos aleatorios o fijos, no tanto porque una clase u objeto dependa de otras clases, para eso están las pruebas que hagas, irte muy al detalle de todas las posibles cosas que puedan pasar en tu código.

Alexander Molinares

student•

Estoy de acuerdo con el comentario de @TatanDiaz, muchas veces una clase depende de otros módulos y al momento de ejecutar un test, no se sabe si el error proviene de la clase que hago test o el modulo del cual depende. Por ejemplo, si tengo una aplicación que usa una API para pedir datos sobre la temperatura de una zona específica, y en base a eso decir si la temperatura > 30°, usar bloqueador solar.

No puedo comprobar al momento del test si la API tendrá algún error y que mi test sea invalido. Debería usar Mockito para desacoplar la dependencia a la API y poder así testear mi clase sola.

Anthony Campos

student•

Problemas con mockito 4.7 en maven 4.13 ? ver - > https://www.youtube.com/watch?v=SvSr8bK6F94 minutos 4 al 5 (actualizar maven)

Ana Guarisma

student•

Gracias!!

Luis Miguel Rodriguez

student•

De maravillaaaaaa <3

Arturo Jesus Gonzalez Villamizar

student•

Otra forma de realizar el ejercicio, importante que exista la linea @RunWith(MockitoJUnitRunner.class)

De no ser así se generaría un NullPointerException

@RunWith(MockitoJUnitRunner.class)
public class PlayerTest {

    @Mock
    Dice dice;
    
    @InjectMocks
    Player player = new Player();

    @Test
    public void lose_when_dice_number_is_too_low() {

        when(dice.roll()).thenReturn(2);

        player = new Player(dice, 3);
        assertFalse(player.play());
    }

    @Test
    public void wins_when_dice_number_is_big() {

        when(dice.roll()).thenReturn(4);

         player = new Player(dice, 3);
        assertTrue(player.play());
    }

}

Cesar David Ramírez Dimaté

student•

Así es. Para las anotaciones @InjectMocks y @Mock es necesario utilizar @RunWith(MockitoJUnitRunner.class) o Mockito.initMocks(this) para inicializar los simuladores (mocks) y poderlos inyectar.

Cesar David Ramírez Dimaté

student•

También lo puedes definir de la siguiente manera, incluso la más óptima (ya que en tu código llamas a dos constructores diferentes).

También, para que no falle, se debe construir un constructor vacío.

Ten en cuenta que los métodos de pruebas es mejor nombrarlos con la convención de CamelCase.

package com.platzi.javatests.player;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class PlayerTest {

  @InjectMocks
  Player player;

  @Mock
  Dice dice;

  @Test
  public void playerLoses_whenNumberIsTooLow() {
    when(dice.roll()).thenReturn(2);

    player = new Player(dice, 3);
    assertFalse(player.play());
  }

  @Test
  public void playerWins_whenNumberIsEqualOrHigh() {
    when(dice.roll()).thenReturn(5);

    player = new Player(dice, 4);
    assertTrue(player.play());
  }
}

Arturo Jesus Gonzalez Villamizar

student•

Hay veces donde los metodos no nos retornan un valor, más lo usan para validar algo, en esas ocasiones se utiliza algo como esto

    @Test
    public void call_to_method() {

        when(dice.roll()).thenReturn(3);
        
        player.play();
        
        Mockito.verify(dice,Mockito.times(1)).roll();
    }```

Cesar David Ramírez Dimaté

student•

Qué hace el método verify() ??

Yone Moreno Jiménez

student•

El método verify de mockito comprueba que** se ha interactuado X veces con el mock**, en este caso nuestro dado: dice.

Si escribimos nuestra propia lista:

public class MyList extends AbstractList<String> {
 
    @Override
    public String get(final int index) {
        return null;
    }
    @Override
    public int size() {
        return 0;
    }
}

Y luego usamos verify ... times:

List<String> mockedList = mock(MyList.class);
mockedList.size();
verify(mockedList, times(1)).size();

Estamos comprobando que hemos interactuado con la lista simulada, llamando 1 vez a alguno de sus métodos, en este caso, size().

Información obtenida de: https://www.baeldung.com/mockito-verify

Sergio Gabriel

student•

<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>5.0.0</version> </dependency>

Alben Daniel Bustamante Barrios

student•

La versión más actualizada:

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>4.7.0</version>
</dependency>

Miguel Angel Martheyn Berbesi

student•

Genial, basicamente JUnit realiza validaciones de valor y con Mockito simulo valores para validar una clase.

Franco Pignanelli

student•

Alguien sabe cómo puedo solucionar esto? Ya probe usando la versión mas nueva y la misma que el profesor pero en todas me dice que no se encuentra

Juan Felipe Jimenez Pacheco

student•

Pruebe View -> Tool Windows -> Maven projects, luego haga clic en el icono azul en la esquina superior izquierda de la ventana de herramientas (Reimport all Maven projects). Debería poder encontrar las dependencias en la vista del proyecto, en bibliotecas externas.

Si esto no funciona, probablemente hay algo mal con su configuración de Maven (pom.xml). Tratar mvn clean install desde la línea de comando, vea si da algún error.

sacado de: https://stackoverflow.com/questions/47453386/intellij-idea-not-resolving-mockito-and-junit-dependencies-with-maven

Jakie Alarcon Reyes

student•

También tuve el mismo problema, lo que hice fue cerrar el IDE, luego buscar en la ruta de mi proyecto el archivo autogenerado .eai y eliminarlo, volver a abrir el proyecto y ya debería de reconocer la dependencia.

fuente: https://stackoverflow.com/questions/47453386/intellij-idea-not-resolving-mockito-and-junit-dependencies-with-maven

Carolina Miñano

student•

los nombre de los métodos test .siguen alguna nomenclatura? se recomienda que sean bien detallados?

David Felipe Garay Pérez

student•

pues el objetivo es que sea claro y auto descriptivo, yo recomiendo que el nombre del test contenga el método a probar, lo que se va a probar y el comportamiento esperado, por ejemplo: Parse_OnEmptyString_ExceptionThrown() pero cada test puede tener su propia complejidad y objetivo, este articulo tiene las mejores practicas para eso, espero te sirve

Juan Fernando López Hernández

student•

Hola yo hice el tercer test. ✌️

Naturalmente el jugador pierde, y nadie gana.

Sebastian CA

student•

Updated:

<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-core</artifactId>
  <version>3.9.0</version>
</dependency>

Jesus David Loera Valverde

student•

mi cabeza al conocer Mockito 🤯

Carlos Villanueva A.

student•

Cuando coloco en el pom.xml el scope test para el JUnit la clase Assert no me es reconocida en mis test, quito el scope y funciona, por que?

David Felipe Garay Pérez

student•

revisa en Project Structure > Modules >Dependencies>scope, de pronto esta molestando porque esta con mayuscula (Test), Tienes que asignar el scope, pues maven utiliza uno para cada fase, y, por ejemplo, hay librerias como la de mockito que no queremos que esten en el proyecto compilado para producción, aqui mas info de maven scope

Gerald Zamora

student•

Y qué pasaría si la clase player no recibiera "Dice dice" como parámetro y, simplemente lo instanciara dentro del método; aun así se quiere controlar lo que devuelve dice.roll() pero ¿cómo?

Anddes Asociados

student•

Si está como clase anidad, al parecer no podríamos utilizar mock con esa sin hacerle referencia antes.

JEISON ESTEBAN TRIANA AMAYA

student•

mi aporte:

Samir Jimenez Vivas

student•

INCREIBLE!! Gracias a este video ya tuve una mejor idea para que sirve el testeo de verdad y como aplicarlo mejor con mockito.

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class PaymentProcessorTest {

        @Mock
        PaymentGateway paymentGateway;
        @InjectMocks
        private PaymentProcessor paymentProcessor;

        @Test
        public void payment_is_correct() {

            Mockito.when(paymentGateway.requestPayment(Mockito.any()))
                    .thenReturn(new PaymentResponse(PaymentResponse.PaymentStatus.OK));

            assertTrue(paymentProcessor.makePayment(1000));
        }

        @Test
        public void payment_is_wrong() {

            Mockito.when(paymentGateway.requestPayment(Mockito.any()))
                    .thenReturn(new PaymentResponse(PaymentResponse.PaymentStatus.ERROR));

            assertFalse(paymentProcessor.makePayment(1000));
        }
}

@RunWith(MockitoJUnitRunner.class)
public class PlayerTest {

    @Mock
    Dice dice;
    
    @InjectMocks
    Player player = new Player();

    @Test
    public void lose_when_dice_number_is_too_low() {

        when(dice.roll()).thenReturn(2);

        player = new Player(dice, 3);
        assertFalse(player.play());
    }

    @Test
    public void wins_when_dice_number_is_big() {

        when(dice.roll()).thenReturn(4);

         player = new Player(dice, 3);
        assertTrue(player.play());
    }

}

package com.platzi.javatests.player;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import static org.junit.Assert.*;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class PlayerTest {

  @InjectMocks
  Player player;

  @Mock
  Dice dice;

  @Test
  public void playerLoses_whenNumberIsTooLow() {
    when(dice.roll()).thenReturn(2);

    player = new Player(dice, 3);
    assertFalse(player.play());
  }

  @Test
  public void playerWins_whenNumberIsEqualOrHigh() {
    when(dice.roll()).thenReturn(5);

    player = new Player(dice, 4);
    assertTrue(player.play());
  }
}

Simulación de Clases en Java con Moquito

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