Testing con Spring Boot Test

El testing representa uno de los pilares fundamentales del desarrollo de software profesional, especialmente en aplicaciones empresariales construidas con Spring Framework. Spring Test proporciona un ecosistema completo de herramientas y anotaciones que facilitan la creación de pruebas robustas y mantenibles.

Fundamentos del testing en Spring

Spring Test se integra perfectamente con JUnit 6 y Mockito, ofreciendo un conjunto de utilidades específicas para probar aplicaciones Spring. Esta integración permite realizar pruebas desde el nivel más granular (unitarias) hasta pruebas de integración completas que involucran múltiples capas de la aplicación.

La arquitectura de Spring facilita el testing mediante su principio de inversión de dependencias. Los componentes Spring son naturalmente testeable gracias a la inyección de dependencias, lo que permite sustituir fácilmente las dependencias reales por mocks o stubs durante las pruebas.

@ExtendWith(SpringExtension.class)
@SpringBootTest
class UsuarioServiceTest {
    
    @Autowired
    private UsuarioService usuarioService;
    
    @MockBean
    private UsuarioRepository usuarioRepository;
    
    @Test
    void deberiaCrearUsuarioCorrectamente() {
        // Given
        Usuario usuario = new Usuario("juan@email.com", "Juan");
        when(usuarioRepository.save(any(Usuario.class))).thenReturn(usuario);
        
        // When
        Usuario resultado = usuarioService.crearUsuario(usuario);
        
        // Then
        assertThat(resultado.getEmail()).isEqualTo("juan@email.com");
        verify(usuarioRepository).save(usuario);
    }
}

Estrategias de testing por capas

El testing en Spring se organiza tradicionalmente siguiendo la arquitectura por capas de la aplicación. Cada capa requiere estrategias específicas de testing que Spring Test facilita mediante anotaciones especializadas.

Testing de la capa de servicio

Los servicios contienen la lógica de negocio y son candidatos ideales para pruebas unitarias. Spring Test permite inyectar mocks de las dependencias mientras se mantiene el contexto de Spring para el componente bajo prueba.

@ExtendWith(SpringExtension.class)
@TestPropertySource(properties = "spring.jpa.hibernate.ddl-auto=none")
class ProductoServiceTest {
    
    @TestConfiguration
    static class TestConfig {
        @Bean
        @Primary
        public ProductoRepository mockProductoRepository() {
            return Mockito.mock(ProductoRepository.class);
        }
    }
    
    @Autowired
    private ProductoService productoService;
    
    @Autowired
    private ProductoRepository productoRepository;
}

Testing de repositorios con Spring Data JPA

Los repositorios Spring Data JPA requieren un enfoque diferente, ya que necesitan una base de datos para funcionar. Spring Test proporciona @DataJpaTest que configura automáticamente una base de datos en memoria y el contexto JPA mínimo necesario.

@DataJpaTest
class ProductoRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private ProductoRepository productoRepository;
    
    @Test
    void deberiaEncontrarProductosPorCategoria() {
        // Given
        Producto producto = new Producto("Laptop", "ELECTRONICA");
        entityManager.persistAndFlush(producto);
        
        // When
        List<Producto> productos = productoRepository.findByCategoria("ELECTRONICA");
        
        // Then
        assertThat(productos).hasSize(1);
        assertThat(productos.get(0).getNombre()).isEqualTo("Laptop");
    }
}

Testing de controladores web

Los controladores Spring MVC manejan las peticiones HTTP y coordinan la interacción entre la capa de presentación y los servicios. Spring Test ofrece MockMvc para simular peticiones HTTP sin necesidad de levantar un servidor web completo.

Testing de controladores con Thymeleaf

Cuando los controladores renderizan vistas Thymeleaf, las pruebas deben verificar tanto la lógica del controlador como la correcta preparación del modelo para la vista.

@WebMvcTest(ProductoController.class)
class ProductoControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private ProductoService productoService;
    
    @Test
    void deberiaMostrarListaProductos() throws Exception {
        // Given
        List<Producto> productos = Arrays.asList(
            new Producto("Laptop", "ELECTRONICA"),
            new Producto("Mouse", "ELECTRONICA")
        );
        when(productoService.obtenerTodos()).thenReturn(productos);
        
        // When & Then
        mockMvc.perform(get("/productos"))
            .andExpect(status().isOk())
            .andExpect(view().name("productos/lista"))
            .andExpect(model().attribute("productos", hasSize(2)))
            .andExpect(content().string(containsString("Laptop")));
    }
}

Testing de APIs REST

Los controladores REST requieren verificar tanto el código de estado HTTP como la estructura y contenido de las respuestas JSON. Spring Test facilita estas verificaciones mediante MockMvc y bibliotecas de aserciones JSON.

@WebMvcTest(ProductoRestController.class)
class ProductoRestControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private ProductoService productoService;
    
    @Test
    void deberiaCrearProductoViaREST() throws Exception {
        // Given
        Producto producto = new Producto("Tablet", "ELECTRONICA");
        when(productoService.crear(any(Producto.class))).thenReturn(producto);
        
        // When & Then
        mockMvc.perform(post("/api/productos")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"nombre\":\"Tablet\",\"categoria\":\"ELECTRONICA\"}"))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.nombre").value("Tablet"))
            .andExpect(jsonPath("$.categoria").value("ELECTRONICA"));
    }
}

Configuración de entornos de testing

Spring Test permite configurar perfiles específicos para testing, lo que facilita el uso de configuraciones diferentes para pruebas y producción. Esto incluye bases de datos en memoria, configuraciones de logging específicas y beans mock.

@ActiveProfiles("test")
@SpringBootTest
class IntegracionTest {
    
    @Autowired
    private UsuarioService usuarioService;
    
    @Test
    void deberiaFuncionarIntegracionCompleta() {
        // Prueba de integración usando perfil 'test'
        Usuario usuario = usuarioService.crearUsuario(
            new Usuario("test@email.com", "Test User")
        );
        
        assertThat(usuario.getId()).isNotNull();
    }
}

Mejores prácticas en Spring Test

El testing efectivo en Spring requiere seguir patrones establecidos que garanticen pruebas rápidas, confiables y mantenibles. Esto incluye el uso apropiado de mocks, la configuración mínima necesaria del contexto Spring y la organización clara de los datos de prueba.

La separación de responsabilidades en las pruebas es crucial. Las pruebas unitarias deben enfocarse en la lógica de un componente específico, mientras que las pruebas de integración verifican la interacción entre múltiples componentes del sistema.

@TestMethodOrder(OrderAnnotation.class)
class UsuarioIntegracionTest {
    
    @Autowired
    private UsuarioService usuarioService;
    
    @Autowired
    private UsuarioRepository usuarioRepository;
    
    @Test
    @Order(1)
    void deberiaCrearUsuario() {
        Usuario usuario = usuarioService.crearUsuario(
            new Usuario("integration@test.com", "Integration Test")
        );
        assertThat(usuario.getId()).isNotNull();
    }
    
    @Test
    @Order(2)
    void deberiaEncontrarUsuarioCreado() {
        Optional<Usuario> usuario = usuarioRepository
            .findByEmail("integration@test.com");
        assertThat(usuario).isPresent();
    }
}

La configuración de datos de prueba debe ser consistente y reproducible. Spring Test proporciona herramientas como @Sql para ejecutar scripts de inicialización de datos antes de cada prueba, garantizando un estado conocido del sistema.