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

Simulación con Mockito

Siguiente ►
►

Introducción

Mockito es una biblioteca de simulación (mocking) para pruebas unitarias en Java. Permite crear objetos simulados (mocks) y definir su comportamiento, lo que facilita la prueba de componentes aislados sin depender de sus dependencias reales. En este tema, aprenderás a usar Mockito para simular dependencias y escribir pruebas unitarias efectivas en Spring Boot.

Conceptos Clave

  1. Simulación (Mocking): Crear objetos simulados que imitan el comportamiento de objetos reales.
  2. Stubbing: Definir el comportamiento de los métodos de los objetos simulados.
  3. Verificación: Comprobar que los métodos de los objetos simulados se llamaron con los parámetros esperados.

Configuración de Mockito

Para usar Mockito en tu proyecto Spring Boot, necesitas agregar la dependencia de Mockito en tu archivo pom.xml:

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

Creando un Test con Mockito

Paso 1: Crear una Clase de Servicio

Supongamos que tienes una clase de servicio UserService que depende de un repositorio UserRepository:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

Paso 2: Crear una Clase de Prueba

Crea una clase de prueba para UserService y usa Mockito para simular UserRepository:

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {

    @InjectMocks
    private UserService userService;

    @Mock
    private UserRepository userRepository;

    @Test
    public void testGetUserById() {
        // Crear un objeto User simulado
        User mockUser = new User();
        mockUser.setId(1L);
        mockUser.setName("John Doe");

        // Definir el comportamiento del método findById del repositorio simulado
        Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));

        // Llamar al método del servicio
        User user = userService.getUserById(1L);

        // Verificar el resultado
        assertNotNull(user);
        assertEquals("John Doe", user.getName());

        // Verificar que el método findById del repositorio se llamó con el parámetro correcto
        Mockito.verify(userRepository).findById(1L);
    }
}

Explicación del Código

  1. Anotaciones:

    • @RunWith(MockitoJUnitRunner.class): Configura el entorno de prueba para usar Mockito.
    • @InjectMocks: Inyecta los mocks en la instancia de UserService.
    • @Mock: Crea un mock de UserRepository.

  2. Stubbing:

    • Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));: Define el comportamiento del método findById del repositorio simulado.

  3. Verificación:

    • Mockito.verify(userRepository).findById(1L);: Verifica que el método findById del repositorio se llamó con el parámetro 1L.

Ejercicio Práctico

Ejercicio 1: Simulación de Dependencias

  1. Crea una clase OrderService que dependa de OrderRepository.
  2. Implementa un método getOrderById(Long id) en OrderService.
  3. Crea una clase de prueba OrderServiceTest y usa Mockito para simular OrderRepository.
  4. Escribe una prueba unitaria para getOrderById(Long id).

Solución

Clase OrderService

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    public Order getOrderById(Long id) {
        return orderRepository.findById(id).orElse(null);
    }
}

Clase de Prueba OrderServiceTest

@RunWith(MockitoJUnitRunner.class)
public class OrderServiceTest {

    @InjectMocks
    private OrderService orderService;

    @Mock
    private OrderRepository orderRepository;

    @Test
    public void testGetOrderById() {
        // Crear un objeto Order simulado
        Order mockOrder = new Order();
        mockOrder.setId(1L);
        mockOrder.setDescription("Sample Order");

        // Definir el comportamiento del método findById del repositorio simulado
        Mockito.when(orderRepository.findById(1L)).thenReturn(Optional.of(mockOrder));

        // Llamar al método del servicio
        Order order = orderService.getOrderById(1L);

        // Verificar el resultado
        assertNotNull(order);
        assertEquals("Sample Order", order.getDescription());

        // Verificar que el método findById del repositorio se llamó con el parámetro correcto
        Mockito.verify(orderRepository).findById(1L);
    }
}

Conclusión

En esta sección, aprendiste a usar Mockito para simular dependencias en tus pruebas unitarias. La simulación te permite probar componentes de manera aislada, asegurando que las pruebas sean más rápidas y confiables. Practica estos conceptos creando y probando más servicios en tu aplicación Spring Boot.

En el siguiente módulo, exploraremos cómo realizar pruebas de integración para asegurar que los diferentes componentes de tu aplicación funcionen correctamente juntos.

◄ Anterior
◄
Siguiente ►
►

Curso de Spring Boot

Módulo 1: Introducción a Spring Boot

Módulo 2: Conceptos Básicos de Spring Boot

Módulo 3: Construyendo Servicios Web RESTful

Módulo 4: Acceso a Datos con Spring Boot

Módulo 5: Seguridad en Spring Boot

Módulo 6: Pruebas en Spring Boot

Módulo 7: Funciones Avanzadas de Spring Boot

Módulo 8: Despliegue de Aplicaciones Spring Boot

Módulo 9: Rendimiento y Monitoreo

Módulo 10: Mejores Prácticas y Consejos

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