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

Pruebas de Integración

Siguiente ►
►

Las pruebas de integración son una parte crucial del desarrollo de software, ya que aseguran que los diferentes componentes de una aplicación funcionen correctamente cuando se combinan. En el contexto de Spring Boot, las pruebas de integración verifican que los componentes de la aplicación, como controladores, servicios y repositorios, funcionen juntos como se espera.

Objetivos de las Pruebas de Integración

  • Verificar la interacción entre componentes: Asegurarse de que los diferentes componentes de la aplicación funcionen correctamente cuando se integran.
  • Detectar problemas de integración: Identificar y resolver problemas que puedan surgir cuando los componentes interactúan entre sí.
  • Validar el comportamiento de la aplicación: Confirmar que la aplicación se comporta como se espera en un entorno que simula el entorno de producción.

Configuración de Pruebas de Integración en Spring Boot

Dependencias Necesarias

Para realizar pruebas de integración en Spring Boot, necesitas incluir las siguientes dependencias en tu archivo pom.xml (para proyectos Maven):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

Configuración del Contexto de Prueba

Spring Boot proporciona la anotación @SpringBootTest para cargar el contexto completo de la aplicación durante las pruebas. Esta anotación se utiliza para indicar que una clase de prueba debe cargar el contexto de la aplicación.

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.junit.runner.RunWith;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyIntegrationTest {
    // Tests go here
}

Ejemplo de Prueba de Integración

Supongamos que tienes una aplicación Spring Boot con un controlador REST y un servicio que interactúa con una base de datos. A continuación, se muestra un ejemplo de cómo escribir una prueba de integración para verificar que el controlador REST y el servicio funcionen correctamente juntos.

Controlador REST

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class MyController {

    private final MyService myService;

    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/data")
    public String getData() {
        return myService.getData();
    }
}

Servicio

import org.springframework.stereotype.Service;

@Service
public class MyService {

    public String getData() {
        return "Hello, World!";
    }
}

Prueba de Integración

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetData() {
        ResponseEntity<String> response = restTemplate.getForEntity("/api/data", String.class);
        assertThat(response.getStatusCodeValue()).isEqualTo(200);
        assertThat(response.getBody()).isEqualTo("Hello, World!");
    }
}

Explicación del Código

  1. Dependencias: Se incluyen las dependencias necesarias para las pruebas de integración y JPA.
  2. Controlador REST: Define un controlador REST con un endpoint /api/data que devuelve un mensaje desde el servicio.
  3. Servicio: Define un servicio que proporciona el mensaje "Hello, World!".
  4. Prueba de Integración:
    • @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT): Carga el contexto completo de la aplicación y asigna un puerto aleatorio para el servidor web.
    • TestRestTemplate: Se utiliza para realizar solicitudes HTTP en las pruebas.
    • testGetData(): Realiza una solicitud GET al endpoint /api/data y verifica que la respuesta sea correcta.

Ejercicios Prácticos

Ejercicio 1: Prueba de Integración con Repositorio JPA

  1. Objetivo: Escribir una prueba de integración para un repositorio JPA que interactúa con una base de datos H2 en memoria.
  2. Instrucciones:
    • Crea una entidad JPA llamada User con campos id y name.
    • Crea un repositorio JPA para la entidad User.
    • Escribe una prueba de integración que guarde un User en la base de datos y verifique que se puede recuperar correctamente.

Solución

Entidad User:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters and setters
}

Repositorio UserRepository:

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

Prueba de Integración:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
public class UserRepositoryIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    @Transactional
    public void testSaveAndFindUser() {
        User user = new User();
        user.setName("John Doe");
        userRepository.save(user);

        User foundUser = userRepository.findById(user.getId()).orElse(null);
        assertThat(foundUser).isNotNull();
        assertThat(foundUser.getName()).isEqualTo("John Doe");
    }
}

Conclusión

En esta sección, hemos aprendido sobre la importancia de las pruebas de integración y cómo configurarlas en una aplicación Spring Boot. Hemos visto ejemplos prácticos de cómo escribir pruebas de integración para controladores REST y repositorios JPA. Las pruebas de integración son esenciales para garantizar que los diferentes componentes de tu aplicación funcionen correctamente cuando se combinan, y te ayudarán a detectar y resolver problemas de integración de manera temprana.

En el siguiente módulo, exploraremos cómo utilizar Mockito para simular dependencias en tus pruebas, lo que te permitirá escribir pruebas más aisladas y enfocadas.

◄ 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