El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

El mocking es una técnica utilizada en las pruebas unitarias para simular el comportamiento de objetos complejos o externos que no son el foco de la prueba. Esto permite aislar la unidad de código que se está probando y verificar su comportamiento de manera más precisa y controlada.

¿Qué es el Mocking?

El mocking implica crear objetos simulados (mocks) que imitan el comportamiento de objetos reales. Estos mocks pueden ser programados para devolver valores específicos, lanzar excepciones o verificar interacciones con otros objetos. El objetivo principal del mocking es:

Aislar la unidad de prueba: Permitir que la prueba se enfoque en la funcionalidad específica sin depender de otros componentes.
Controlar el entorno de prueba: Simular diferentes escenarios y comportamientos que pueden ser difíciles de reproducir con objetos reales.
Verificar interacciones: Asegurarse de que los métodos de los objetos simulados se llamen de la manera esperada.

¿Cuándo usar el Mocking?

El mocking es útil en varias situaciones, tales como:

Dependencias externas: Cuando el código que se está probando depende de servicios externos, como bases de datos, APIs web, o sistemas de archivos.
Comportamiento complejo: Cuando los objetos tienen comportamientos complejos que son difíciles de configurar o controlar en una prueba.
Pruebas de integración: Para simular componentes que aún no están implementados o que no están disponibles durante la prueba.

Herramientas de Mocking

Existen varias bibliotecas de mocking disponibles para Java, siendo las más populares:

Mockito: Una de las bibliotecas de mocking más utilizadas en el ecosistema Java. Es fácil de usar y proporciona una amplia gama de funcionalidades.
EasyMock: Otra biblioteca popular que permite crear mocks y verificar interacciones de manera sencilla.
JMock: Una biblioteca de mocking que se enfoca en la creación de expectativas y la verificación de interacciones.

En este curso, nos centraremos en Mockito debido a su popularidad y facilidad de uso.

Ejemplo Básico de Mocking con Mockito

A continuación, se presenta un ejemplo básico de cómo usar Mockito para crear un mock y verificar su comportamiento.

Paso 1: Configuración del Proyecto

Primero, asegúrate de tener Mockito en tu proyecto. Si estás usando Maven, agrega la siguiente dependencia en tu archivo pom.xml:

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

Paso 2: Crear un Mock

Supongamos que tenemos una clase Servicio y queremos probar una clase Cliente que depende de Servicio.

public class Servicio {
    public String obtenerDatos() {
        // Lógica compleja o llamada a un servicio externo
        return "Datos reales";
    }
}

public class Cliente {
    private Servicio servicio;

    public Cliente(Servicio servicio) {
        this.servicio = servicio;
    }

    public String procesarDatos() {
        String datos = servicio.obtenerDatos();
        return "Procesado: " + datos;
    }
}

Paso 3: Escribir el Test con Mockito

Ahora, escribimos una prueba para la clase Cliente usando Mockito para simular el comportamiento de Servicio.

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

public class ClienteTest {

    @Test
    public void testProcesarDatos() {
        // Crear un mock de la clase Servicio
        Servicio servicioMock = mock(Servicio.class);

        // Configurar el mock para devolver un valor específico
        when(servicioMock.obtenerDatos()).thenReturn("Datos simulados");

        // Crear una instancia de Cliente con el mock
        Cliente cliente = new Cliente(servicioMock);

        // Llamar al método a probar
        String resultado = cliente.procesarDatos();

        // Verificar el resultado
        assertEquals("Procesado: Datos simulados", resultado);

        // Verificar que el método obtenerDatos() fue llamado una vez
        verify(servicioMock).obtenerDatos();
    }
}

Explicación del Código

Crear un mock: Servicio servicioMock = mock(Servicio.class); crea un mock de la clase Servicio.
Configurar el mock: when(servicioMock.obtenerDatos()).thenReturn("Datos simulados"); configura el mock para que devuelva "Datos simulados" cuando se llame al método obtenerDatos().
Usar el mock: Se pasa el mock al constructor de Cliente y se llama al método procesarDatos().
Verificar el resultado: assertEquals("Procesado: Datos simulados", resultado); verifica que el resultado sea el esperado.
Verificar interacciones: verify(servicioMock).obtenerDatos(); verifica que el método obtenerDatos() fue llamado exactamente una vez.

Conclusión

El mocking es una técnica poderosa que permite aislar y controlar el comportamiento de las dependencias en las pruebas unitarias. En este módulo, hemos introducido los conceptos básicos del mocking y cómo usar Mockito para crear y configurar mocks. En los siguientes temas, profundizaremos en el uso de Mockito con JUnit y exploraremos técnicas avanzadas de mocking.

En el próximo tema, aprenderemos a usar Mockito con JUnit para crear pruebas más robustas y efectivas.

Introducción al Mocking

¿Qué es el Mocking?

¿Cuándo usar el Mocking?

Herramientas de Mocking

Ejemplo Básico de Mocking con Mockito

Paso 1: Configuración del Proyecto

Paso 2: Crear un Mock

Paso 3: Escribir el Test con Mockito

Explicación del Código

Conclusión

Curso de JUnit

Módulo 1: Introducción a JUnit

Módulo 2: Anotaciones Básicas de JUnit

Módulo 3: Aserciones en JUnit

Módulo 4: Tests Parametrizados

Módulo 5: Suites de Tests

Módulo 6: Mocking con JUnit

Módulo 7: Características Avanzadas de JUnit

Módulo 8: Mejores Prácticas y Consejos

Módulo 9: Nuevas Características de JUnit 5