José Luis García Peceros
Elioenai Garcia
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
Elioenai Garcia
Ferran Maylinch
ProfesorLuzdelia Alba
Juan Manuel Alberto Martin
Alexis Rodriguez Jimenez
César David Ramírez Dimaté
Sebastian Diaz
César David Ramírez Dimaté
Alexander Molinares
Anthony Campos
Ana Guarisma
Luis Miguel Rodríguez
Arturo Jesus Gonzalez Villamizar
César David Ramírez Dimaté
César David Ramírez Dimaté
Arturo Jesus Gonzalez Villamizar
César David Ramírez Dimaté
Yone Moreno Jiménez
Sergio Gabriel
Alben Daniel Bustamante Barrios
Miguel Angel Martheyn Berbesi
Franco Pignanelli
Juan Felipe Jimenez Pacheco
Jakie Alarcon Reyes
Carolina Miñano
David Felipe Garay Pérez
Juan Fernando López Hernández
Sebastian CA
Jesus David Loera Valverde
Carlos Villanueva A.
David Felipe Garay Pérez
Gerald Zamora
Anddes Asociados
JEISON ESTEBAN TRIANA AMAYA
Samir Jimenez Vivas
<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>2.23.4</version> <scope>test</scope> </dependency>
Por con esta versión si funciona y en las recientes no para java 8? 🥸
Perder sería "lose", no "loose". Sorry! 😅
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>
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)); } }
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?
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.
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.
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.
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.
Problemas con mockito 4.7 en maven 4.13 ? ver - > https://www.youtube.com/watch?v=SvSr8bK6F94 minutos 4 al 5 (actualizar maven)
Gracias!!
De maravillaaaaaa <3
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()); } }
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.
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()); } }
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(); }```
Qué hace el método verify() ??
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
La versión más actualizada:
<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>4.7.0</version> </dependency>
Genial, basicamente JUnit realiza validaciones de valor y con Mockito simulo valores para validar una clase.
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
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.
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.
los nombre de los métodos test .siguen alguna nomenclatura? se recomienda que sean bien detallados?
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
Hola yo hice el tercer test. ✌️
Updated:
<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <version>3.9.0</version> </dependency>
mi cabeza al conocer Mockito 🤯
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?
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
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?
Si está como clase anidad, al parecer no podríamos utilizar mock con esa sin hacerle referencia antes.
mi aporte:
INCREIBLE!! Gracias a este video ya tuve una mejor idea para que sirve el testeo de verdad y como aplicarlo mejor con mockito.