En el desarrollo de software, mantener un código de alta calidad es crucial, especialmente a medida que los sistemas crecen en complejidad. Las pruebas automatizadas desempeñan un papel fundamental para garantizar que las nuevas funciones no interrumpan la funcionalidad existente y que el código siga siendo sólido y confiable a lo largo del tiempo. Para las aplicaciones Spring Boot, JUnit y Mockito son dos de las herramientas más populares para pruebas unitarias y simulación de dependencias, respectivamente. En esta publicación, exploraremos cómo aprovechar estas herramientas para crear pruebas automatizadas efectivas en Spring Boot, asegurando que su aplicación permanezca estable y mantenible.

JUnit es un marco de prueba ampliamente utilizado para Java que proporciona anotaciones y afirmaciones para ayudar a estructurar y ejecutar pruebas de manera efectiva. Permite a los desarrolladores escribir pruebas repetibles y admite pruebas unitarias y de integración. Por otro lado, Mockito es un poderoso marco de simulación que permite la creación de objetos simulados con fines de prueba. Permite a los desarrolladores simular el comportamiento de dependencias complejas, aislando la funcionalidad bajo prueba. Al usar JUnit en combinación con Mockito, podemos probar exhaustivamente la lógica empresarial de nuestras aplicaciones Spring Boot sin depender de conexiones de bases de datos reales, servicios externos o configuraciones complejas.

Profundicemos en un ejemplo práctico para ver cómo JUnit y Mockito se pueden usar juntos en una aplicación Spring Boot. Crearemos una clase de servicio simple y escribiremos pruebas para ella usando JUnit y Mockito.

Supongamos que tenemos una clase UserService que depende de un UserRepository para recuperar datos del usuario:

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

Aquí, UserService depende de UserRepository, que es una interfaz de repositorio Spring Data JPA. Para probar el método getUserById sin acceder a la base de datos, podemos usar Mockito para burlarnos del UserRepository y JUnit para afirmar el comportamiento de UserService.

Así es como podemos escribir una prueba para UserService:

@SpringBootTest
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testGetUserById_Success() {
        // Arrange
        User user = new User(1L, "John Doe", "[email protected]");
        when(userRepository.findById(1L)).thenReturn(Optional.of(user));

        // Act
        User result = userService.getUserById(1L);

        // Assert
        assertEquals("John Doe", result.getName());
        assertEquals("[email protected]", result.getEmail());
    }

    @Test
    public void testGetUserById_UserNotFound() {
        // Arrange
        when(userRepository.findById(1L)).thenReturn(Optional.empty());

        // Act & Assert
        assertThrows(UserNotFoundException.class, () -> userService.getUserById(1L));
    }
}

En la clase UserServiceTest, usamos la anotación @Mock para crear una instancia simulada de UserRepository y la anotación @InjectMocks para inyectar esta instancia simulada en UserService. El método setUp inicializa los simulacros antes de cada prueba.

Luego definimos dos pruebas:

testGetUserById_Success: esta prueba verifica que cuando UserRepository encuentra un usuario, UserService devuelve el usuario correcto.
testGetUserById_UserNotFound: esta prueba garantiza que cuando UserRepository devuelve un resultado vacío, UserService arroja una UserNotFoundException.
Estas pruebas nos permiten validar el comportamiento de UserService sin tener que depender de una base de datos real, haciéndolos más rápidos y confiables.

La automatización de pruebas con JUnit y Mockito en aplicaciones Spring Boot proporciona una forma poderosa de garantizar la calidad del código y la estabilidad de la aplicación. Al escribir pruebas unitarias integrales, los desarrolladores pueden detectar errores en las primeras etapas del proceso de desarrollo, lo que facilita la refactorización del código y la adición de nuevas funciones con confianza. La combinación de JUnit y Mockito permite pruebas claras y concisas que se centran en la lógica empresarial de su aplicación, libres de las complejidades de las dependencias externas.

Adoptar las pruebas automatizadas como práctica principal no solo mejora la confiabilidad de su código base, sino que también mejora el flujo de trabajo de desarrollo general. Al integrar estas pruebas en su canal de CI/CD, garantiza que los controles de calidad estén automatizados y sean consistentes, allanando el camino para un proceso de desarrollo más ágil y resiliente. Entonces, ya sea que esté iniciando un nuevo proyecto o mejorando uno existente, haga que las pruebas automatizadas con JUnit y Mockito formen parte de su estrategia de desarrollo.