Qué es mockito

Tiempo de lectura estimado: 6 minutos

En el mundo del desarrollo de software, las pruebas unitarias son un elemento fundamental para garantizar la calidad del código.

Sin embargo, no siempre es sencillo probar clases que dependen de servicios externos, bases de datos, APIs, o componentes complejos.

Aquí es donde entra en juego Mockito, una de las bibliotecas de mocking más utilizadas por desarrolladores Java y equipos de testing en todo el mundo.

Mockito se ha convertido en un recurso esencial para escribir pruebas unitarias limpias, rápidas y fiables. Gracias a su facilidad de uso y su integración con frameworks como JUnit y Spring, es una herramienta clave en cualquier estrategia profesional de testing.
En este artículo descubrirás qué es Mockito, para qué sirve, cómo funciona internamente y cómo usarlo con ejemplos prácticos.

1. ¿Qué es Mockito?

Mockito es un framework de mocking para Java que permite simular el comportamiento de dependencias externas dentro de una prueba unitaria.

Su propósito principal es permitir que una clase se pruebe sin necesidad de ejecutar sus dependencias reales.

En otras palabras:

👉 Mockito crea objetos falsos (mocks) que imitan el comportamiento de clases reales.
👉 Te permite controlar lo que devuelven, cómo actúan y cómo responden ante determinadas llamadas.
👉 Facilita la verificación de si ciertos métodos fueron llamados, cuántas veces y con qué parámetros.

Esto hace que Mockito sea una herramienta ideal en escenarios como:

• Probar servicios sin conexión a base de datos
• Simular respuestas de APIs externas
• Evitar dependencias costosas, lentas o inestables
• Aislar una clase y validar únicamente su lógica

Mockito es conocido por su sintaxis fluida y por permitir escribir pruebas altamente legibles, lo que ha contribuido enormemente a su popularidad.

2. ¿Para qué sirve Mockito?

🚀 ¿Quieres empezar en QA pero no sabes por dónde hacerlo?

La mayoría de personas que hoy trabajan como testers empezaron exactamente desde cero, sin experiencia técnica ni saber programar.

He creado una ruta clara paso a paso para que entiendas:

✅ qué aprender primero
✅ qué evitar para no perder meses
✅ cómo pasar de principiante a tu primer trabajo en testing

👉 Ver la Ruta QA desde Cero

Mockito sirve principalmente para crear mocks y stubs que ayudan a probar código sin utilizar dependencias reales. Estos son los principales usos del framework:

2.1 Simulación de dependencias complejas

Si tu clase accede a bases de datos, microservicios o archivos de sistema, Mockito puede simular esos componentes sin ejecutar nada real.

Ejemplo:

• Tu servicio necesita datos de un repositorio
• En lugar de conectarte a la base de datos, creas un mock del repositorio
• Le indicas qué debe devolver

2.2 Control total del comportamiento

Puedes decidir:

• Qué retornan los métodos del mock
• Qué excepciones deben lanzar
• Cómo deben reaccionar ante ciertas llamadas

2.3 Verificación de interacción

Mockito permite confirmar:

• Si un método fue llamado
• Cuántas veces
• En qué orden
• Con qué parámetros

Esto es muy útil para probar patrones como service → repository → external service.

2.4 Aislamiento de lógica

Cuando pruebas una clase, Mockito te permite enfocarte solo en ella, sin interferencias del sistema.

3. Cómo funciona internamente

Mockito utiliza técnicas avanzadas de Java como:

• Reflexión
• Proxies dinámicos
• Bytecode manipulation (ByteBuddy)

Esto permite interceptar llamadas a métodos sin modificar la clase original.

Cuando creas un mock:

MyService service = mock(MyService.class);

Mockito genera una versión dinámica de la clase que:

1. No ejecuta la lógica original
2. Captura llamadas
3. Retorna valores programados
4. Registra interacciones

El resultado es un objeto muy ligero, rápido y controlable.

4. Ventajas clave

Mockito no es popular por casualidad. Estas son sus mayores ventajas:

4.1 Simplicidad

Sintaxis clara y fluida:

when(repo.findUser()).thenReturn(user);

4.2 Integración con JUnit y Spring Boot

Funciona perfectamente con:

• JUnit 4
• JUnit 5
• Spring Testing Framework

4.3 Pruebas más rápidas

Sin conexiones reales, todo se ejecuta en milisegundos.

4.4 Pruebas más fiables

Evita flujos relacionados a infraestructura.

4.5 Código más aislado

Aísla el comportamiento real para validar solo la lógica que interesa.

5. Conceptos fundamentales

Aquí tienes lo más importante para entender Mockito:

5.1 Mock

Objeto falso que simula comportamiento.

MyRepo repo = mock(MyRepo.class);

5.2 Stub

Programación del comportamiento del mock.

when(repo.findById(1)).thenReturn(user);

5.3 Verificación

Comprueba interacciones:

verify(repo).findById(1);

5.4 Argument Matchers

Comparadores flexibles:

when(repo.save(any(User.class))).thenReturn(true);

5.5 Spies

Mocks parciales (usan código real salvo métodos simulados):

List list = spy(new ArrayList());

6. Ejemplo práctico usando Mockito

Este ejemplo demuestra cómo probar un servicio que depende de un repositorio.

Clase a probar:

public class UserService {

    private UserRepository repository;

    public UserService(UserRepository repository) {
        this.repository = repository;
    }

    public User getUserById(int id) {
        return repository.findById(id);
    }
}

Prueba con Mockito:

class UserServiceTest {

    @Test
    void testGetUserById() {
        UserRepository mockRepo = mock(UserRepository.class);
        UserService service = new UserService(mockRepo);

        User mockUser = new User(1, "Carlos");

        when(mockRepo.findById(1)).thenReturn(mockUser);

        User result = service.getUserById(1);

        assertEquals("Carlos", result.getName());
        verify(mockRepo).findById(1);
    }
}

Con esto:

• Simulamos el repositorio
• Indicamos qué devolver
• Verificamos la interacción
• Probamos la lógica real del servicio

7. Mockito en Spring Boot

Mockito se integra perfectamente con Spring gracias a:

@MockBean

Crea un mock gestionado por Spring.

@MockBean
private UserRepository repo;

@InjectMocks

Inyecta los mocks automáticamente.

@InjectMocks
private UserService service;

Combinado con JUnit 5, permite pruebas potentes y fáciles de mantener.

8. Mejores prácticas

✔ Evita mockear lo que no necesitas

No mockees clases simples o DTOs.

✔ Mockea solo dependencias externas

Bases de datos, servicios externos, APIs, etc.

✔ Usa argument matchers consistentemente

No mezcles any() con valores concretos.

✔ Verifica solo lo necesario

Evita verificaciones excesivas.

✔ Mantén tus tests pequeños y legibles

9. ¿Cuándo NO usar Mockito?

Mockito no es útil en casos como:

• Pruebas de integración
• Pruebas de componentes reales
• Pruebas que requieren comportamiento real (bases de datos, APIs, etc.)

Si necesitas probar flujos reales, entonces Mockito NO es la herramienta adecuada.

10. Comparación entre Mockito y otros frameworks

Mockito vs. PowerMock

Mockito vs. EasyMock

Mockito es más flexible y su sintaxis es más fluida.

PowerMock permite mockear métodos privados, estáticos y finales.
Mockito es más simple y moderno.

Mockito vs. JMockit

Mockito es más popular y con mejor soporte.

Conclusión: ¿Por qué usar Mockito?

Mockito es el framework de mocking más popular para Java porque:

• Permite crear pruebas unitarias potentes
• Facilita el aislamiento de dependencias
• Integra perfectamente con JUnit y Spring
• Mejora la calidad y velocidad del desarrollo

Si trabajas con Java y buscas mejorar tu estrategia de pruebas, Mockito es una herramienta imprescindible.

Te dejo esta infografía como resumen del artículo

También te dejo un vídeo resumen para que entiendas que es mockito.

🎙️ Episodio: ¿Qué es Mockito y para qué sirve?
En este episodio te explico qué es Mockito, cómo funciona este popular framework de Java para crear objetos simulados (mocks) y cómo se usa en pruebas unitarias para aislar dependencias y probar comportamientos.

Te ha gustado el artículo ?Inscribete en nuestro curso de programación en phyton

Alejandro Canosa

Alejandro Canosa es especialista en QA y testing de software con más de 10 años de experiencia profesional trabajando entre España y Colombia. Cuenta con un posgrado en Quality Assurance por la UPC y es autor de dos libros técnicos publicados por la editorial Rama como son Scrum.Teoría e implementación práctica y Certificación ISTQB Certified Foundation Level 4.0 además es socio de CEDRO . Actualmente dirige Academia de Testing, donde ayuda a personas sin experiencia previa a iniciar su carrera en tecnología desde cero.