Test con Mockito para simular un dado

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

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));
        }
}

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.

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

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());
    }

}

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();
    }```

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

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.

Hola yo hice el tercer test. ✌️

Naturalmente el jugador pierde, y nadie gana.

Updated:

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

mi cabeza al conocer Mockito 🤯

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

Me ha parecido super interesante este curso, no había trabajado nunca con Java, pero he logrado hacer todos los ejercicios explicados en los videos de forma satisfactoria, entonces eso me estimula favorablemente para seguir aprendiendo más acerca de los Testing en Java.

⚡️Ir al resumen del curso

⚡️Ir al resumen del curso

Test Unitario, librerias
JUnit --> para comprobar valores
Mockito --> Simular un valor estático, de una clase.

para el año 2023:

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

recuerden actualizar el maven para que logre importar las librerias 😃

Gran curso!

Algo viejo el curso, sin embargo el material es muy bueno, ojo, para Julio 2023, estas dependencias que son las del momento, usar con Java 11

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.9.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>5.4.0</version>
        </dependency>
    </dependencies>

si a alguien no le funciona la dependencia, vayanse a la parte de la derecha donde esta la ventana maven y denle a la ruedita de update para que se le actualice la dependence

Enlace directo de para importar la libreria de Mockito:
https://central.sonatype.com/search?smo=true&q=mockito-core

Para los que tengan problemas con la dependencia esta solución les puede ayudar: Solucion

Gracias

Excelente explicación de como usar e implementar los Test Unitarios con JUnit y usar la librería Mockito para simulaciones

Se emplea la librería mockito para poder realizar inyecciones sobre los objetos creados, esta función está pensada, para desacoplar nuestro de test de elementos externos, como apis, web services o algún elementos que pueda no estar disponible, cuando se estén corriendo los test…
En kotlin, se tiene que hacer ciertos ajustes para poder utilizar esta librería.
Link de referencia https://antonioleiva.com/mockito-2-kotlin/

Si se usa Kotlin, se debe de agregar la librería que se marca el archivo o la más reciente probada la 3.3.0.
Se debe crear la siguiente ruta(Para hacerlo más fácil colocar la vista en proyecto),
app/test**/resources/mockito-extensions/**
Dentro de esa ruta crear el archivo .tex con nombre org.mockito.plugins.MockMaker.
Dentro del archivo escribir la siguiente instrucción mock-maker-inline

Estos pasos son para evitar el error al correr los test en Kotlin, que indican que la clase debe ser final.
(En caso de que estos paso no funcionen, favor de seguir el link, donde alguien que si sabe del tema, lo redacto mejor y explico mucho mejor.)
Para poder inyectar respuestas acorde akl test, se utiliza la instrucción Mockito.´when´(objeto.metodo).thenReturn(resultado), de esta manera podemos interceptar el método y cuando este método sea utilizado en el test, podamos obtener el valor esperado.

Excelente, una forma sencilla de mostrar como funcionan Mockito a nivel básico pero entendible.

Estupenda clase instructor Ferran, no sabía que además de simular, Mockito también nos permitiría prestablecer los valores que queramos tener durante las pruebas, esta va a ser una muy buena herramienta a aprovechar.

Super 😃

😮 el IDE te hace la vida mas sencilla, definitivmente.

Muy buen uso de mockito y bastante sencillo ya al ponerlo en practica en una logica de negocio es de conocerla mejor, pero esta bastante bueno el ejemplo.