El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Creando Mocks

Siguiente ►
►

En este tema, aprenderemos cómo crear mocks utilizando JUnit y la biblioteca Mockito. Los mocks son objetos simulados que imitan el comportamiento de objetos reales en un entorno controlado. Son especialmente útiles en pruebas unitarias para aislar el código que se está probando y evitar dependencias externas.

¿Qué es un Mock?

Un mock es un objeto que simula el comportamiento de un objeto real. En las pruebas unitarias, los mocks se utilizan para:

  • Imitar el comportamiento de dependencias externas.
  • Controlar el entorno de prueba.
  • Verificar interacciones entre objetos.

Configuración de Mockito

Antes de comenzar a crear mocks, necesitamos configurar Mockito en nuestro proyecto. Asegúrate de tener las siguientes dependencias en tu archivo pom.xml si estás usando Maven:

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

Para Gradle, agrega la siguiente línea a tu archivo build.gradle:

testImplementation 'org.mockito:mockito-core:3.11.2'

Creando un Mock con Mockito

Paso 1: Importar Mockito

Primero, necesitamos importar las clases necesarias de Mockito:

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

Paso 2: Crear el Mock

Para crear un mock, utilizamos el método mock() de Mockito. Aquí hay un ejemplo de cómo crear un mock de una clase MyService:

public class MyServiceTest {

    @Test
    public void testMyService() {
        // Crear un mock de MyService
        MyService myServiceMock = mock(MyService.class);

        // Definir el comportamiento del mock
        when(myServiceMock.performAction()).thenReturn("Mocked Result");

        // Usar el mock en el test
        String result = myServiceMock.performAction();

        // Verificar el resultado
        assertEquals("Mocked Result", result);
    }
}

Explicación del Código

  1. Crear el Mock: MyService myServiceMock = mock(MyService.class);

    • Utilizamos el método mock() para crear un mock de la clase MyService.

  2. Definir el Comportamiento del Mock: when(myServiceMock.performAction()).thenReturn("Mocked Result");

    • Utilizamos el método when() para definir el comportamiento del mock. En este caso, cuando se llame al método performAction(), el mock devolverá "Mocked Result".

  3. Usar el Mock en el Test: String result = myServiceMock.performAction();

    • Llamamos al método performAction() en el mock y almacenamos el resultado.

  4. Verificar el Resultado: assertEquals("Mocked Result", result);

    • Verificamos que el resultado sea el esperado.

Ejercicio Práctico

Ejercicio 1: Crear un Mock y Definir su Comportamiento

  1. Crea una clase Calculator con un método add(int a, int b) que devuelve la suma de dos números.
  2. Crea un test para la clase Calculator utilizando Mockito.
  3. Crea un mock de Calculator y define el comportamiento del método add() para que devuelva un valor específico.
  4. Verifica que el mock se comporte como se espera.

Solución

// Clase Calculator
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// Test de Calculator
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {

    @Test
    public void testAdd() {
        // Crear un mock de Calculator
        Calculator calculatorMock = mock(Calculator.class);

        // Definir el comportamiento del mock
        when(calculatorMock.add(2, 3)).thenReturn(10);

        // Usar el mock en el test
        int result = calculatorMock.add(2, 3);

        // Verificar el resultado
        assertEquals(10, result);
    }
}

Retroalimentación sobre Errores Comunes

  • No Definir el Comportamiento del Mock: Si no defines el comportamiento del mock, devolverá valores predeterminados (por ejemplo, null para objetos, 0 para enteros).
  • No Importar Correctamente Mockito: Asegúrate de importar las clases necesarias de Mockito para evitar errores de compilación.
  • Confundir Mocks con Stubs: Los mocks no solo simulan el comportamiento, sino que también permiten verificar interacciones. Los stubs solo simulan el comportamiento.

Conclusión

En esta sección, hemos aprendido cómo crear mocks utilizando Mockito y JUnit. Los mocks son herramientas poderosas para aislar el código en pruebas unitarias y controlar el entorno de prueba. En el siguiente tema, exploraremos cómo verificar interacciones con mocks para asegurarnos de que los métodos se llamen como se espera.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados