Artículo

Qué es Mockito: pruebas unitarias en Java con ejemplos

Mockito es un framework de Java para crear mocks en pruebas unitarias. Aprende @Mock, @InjectMocks, when, verify y su uso con JUnit 5, con ejemplos.

Qué es Mockito: pruebas unitarias en Java con ejemplos

Mockito es un framework de Java para crear objetos simulados (mocks) en pruebas unitarias. Sustituye las dependencias reales de una clase (un repositorio, un cliente HTTP) por dobles que tú controlas, para probar esa clase de forma aislada. Ejemplos probados con Mockito 5.23 y JUnit Jupiter.

Vídeo explicativo

¿Qué es Mockito?

Mockito es la librería de mocking más usada en Java. Con ella haces tres cosas:

  1. Crear un mock: un objeto falso con la misma interfaz que la dependencia real.
  2. Programar su respuesta con when(...).thenReturn(...) o thenThrow(...).
  3. Verificar con verify(...) que tu código llamó a la dependencia como esperabas.

Mockito no ejecuta los tests: de eso se encarga JUnit 5. Los dos se usan juntos.

¿Para qué sirve un mock?

Una prueba unitaria comprueba una sola clase. Si UsuarioServicio necesita un UsuarioRepositorio que habla con la base de datos, un test con el repositorio real sería lento y fallaría por motivos ajenos al servicio. Con un mock decides qué devuelve el repositorio en cada caso, incluidos los difíciles de provocar: un usuario que no existe o una base de datos caída.

Este es el código que vamos a probar en todo el artículo:

record Usuario(long id, String nombre) {}

interface UsuarioRepositorio {
    Optional<Usuario> buscarPorId(long id);
    void guardar(Usuario usuario);
}

class UsuarioServicio {
    private final UsuarioRepositorio repositorio;

    UsuarioServicio(UsuarioRepositorio repositorio) {
        this.repositorio = repositorio;
    }

    Usuario obtener(long id) {
        return repositorio.buscarPorId(id)
                .orElseThrow(() -> new NoSuchElementException("Usuario no encontrado"));
    }

    Usuario registrar(String nombre) {
        Usuario usuario = new Usuario(1L, nombre.trim());
        repositorio.guardar(usuario);
        return usuario;
    }
}

Añadir Mockito al proyecto

Si usas Spring Boot, spring-boot-starter-test ya incluye Mockito y JUnit: no añadas nada. En un proyecto sin Spring, añade mockito-junit-jupiter, que trae mockito-core y la extensión para JUnit 5.

Maven

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>5.23.0</version>
    <scope>test</scope>
</dependency>

Gradle

testImplementation("org.mockito:mockito-junit-jupiter:5.23.0")

Activar Mockito en JUnit 5

Para que las anotaciones @Mock e @InjectMocks funcionen, registra la extensión de Mockito en la clase de test:

@ExtendWith(MockitoExtension.class)
class UsuarioServicioTest {
    // ...
}

En JUnit 4 el equivalente es @RunWith(MockitoJUnitRunner.class). Si no puedes usar ninguna de las dos, llama a MockitoAnnotations.openMocks(this) en un método @BeforeEach.

Crear mocks: mock() y @Mock

La forma más directa es el método estático mock():

@Test
void mockSencillo() {
    List<String> lista = mock(List.class);
    when(lista.size()).thenReturn(5);

    assertEquals(5, lista.size());
}

Cuando el mock se usa en varios tests, declara un campo con @Mock. Mockito lo crea de nuevo antes de cada test:

@Mock
UsuarioRepositorio repositorio;

Un mock sin programar no falla: devuelve null, 0, false, una colección vacía o un Optional vacío, según el tipo de retorno.

Inyectar los mocks con @InjectMocks

@InjectMocks crea una instancia real de la clase que pruebas y le pasa los campos anotados con @Mock, por constructor si lo hay:

@ExtendWith(MockitoExtension.class)
class UsuarioServicioTest {

    @Mock
    UsuarioRepositorio repositorio;

    @InjectMocks
    UsuarioServicio servicio;
}

servicio no es un mock: es un UsuarioServicio de verdad cuyo repositorio es el simulado.

Programar respuestas: when().thenReturn() y thenThrow()

when(...).thenReturn(...) define qué devuelve el mock cuando recibe esa llamada:

@Test
void devuelveElUsuarioCuandoExiste() {
    when(repositorio.buscarPorId(1L)).thenReturn(Optional.of(new Usuario(1L, "Juan")));

    Usuario resultado = servicio.obtener(1L);

    assertEquals("Juan", resultado.nombre());
}

Si pasas varios valores a thenReturn, se devuelven en orden y el último se repite. Para aceptar cualquier argumento usa los matchers de ArgumentMatchers, como anyLong() o anyString().

Para simular un fallo de la dependencia, usa thenThrow y comprueba la excepción con assertThrows (más detalle en cómo probar excepciones con JUnit):

@Test
void propagaElErrorDelRepositorio() {
    when(repositorio.buscarPorId(1L)).thenThrow(new IllegalStateException("Base de datos caída"));

    IllegalStateException error =
            assertThrows(IllegalStateException.class, () -> servicio.obtener(1L));

    assertEquals("Base de datos caída", error.getMessage());
}

Verificar llamadas con verify()

Algunos métodos no devuelven nada útil: su efecto es llamar a la dependencia. verify comprueba que esa llamada ocurrió, y ArgumentCaptor captura el argumento para examinarlo:

@Captor
ArgumentCaptor<Usuario> captor;

@Test
void guardaElUsuarioRegistrado() {
    servicio.registrar("  Ana ");

    verify(repositorio).guardar(captor.capture());
    assertEquals("Ana", captor.getValue().nombre());
    verify(repositorio, never()).buscarPorId(anyLong());
}

verify(mock) exige una llamada exacta. Con times(2), never() o atLeastOnce() cambias el número esperado.

@Mock, @Spy e @InjectMocks: diferencias

AnotaciónQué creaCuándo usarla
@MockObjeto falso: ningún método real se ejecutaDependencias de la clase que pruebas
@SpyObjeto real en el que puedes sustituir métodos concretosCuando necesitas casi todo el comportamiento real
@InjectMocksInstancia real de la clase bajo prueba, con sus mocks inyectadosLa clase que estás probando

En tests de Spring Boot que levantan el contexto existen además @MockitoBean y @MockitoSpyBean, que sustituyen un bean del contexto por un mock. Tienes la comparación en diferencias entre @Spy y @SpyBean.

Errores habituales

  • UnnecessaryStubbingException: programaste un when(...) que el test no llega a usar. La extensión de JUnit 5 lo trata como error. Borra ese when o muévelo al test que lo necesita.
  • El mock devuelve null: la llamada real no coincide con la programada (otro argumento, otro método). Revisa los argumentos o usa un matcher.
  • Mezclar matchers y valores: si un argumento usa any(), todos deben ser matchers. Envuelve los valores fijos con eq(valor).
  • Simular todo: no hagas mocks de records, DTO o colecciones. Créalos de verdad. Reserva los mocks para dependencias con efectos externos.

Preguntas frecuentes

¿Qué es Mockito?

Mockito es un framework de Java para crear objetos simulados (mocks) en pruebas unitarias. Permite sustituir las dependencias de una clase, definir qué devuelven y verificar cómo se usaron.

¿Cuál es la diferencia entre JUnit y Mockito?

JUnit ejecuta los tests y aporta las aserciones. Mockito crea los objetos simulados que esos tests necesitan. No compiten: se usan juntos.

¿Qué diferencia hay entre @Mock e @InjectMocks?

@Mock crea un objeto simulado. @InjectMocks crea una instancia real de la clase que pruebas y le inyecta los objetos anotados con @Mock.

¿Mockito puede simular clases final o métodos estáticos?

Sí. Desde Mockito 5 el mock maker por defecto permite simular clases y métodos final. Los métodos estáticos se simulan con Mockito.mockStatic() dentro de un bloque try-with-resources.

¿Necesito Mockito si uso Spring Boot?

Ya lo tienes: spring-boot-starter-test lo incluye. En tests unitarios úsalo con MockitoExtension, sin levantar el contexto de Spring, porque son mucho más rápidos.

Artículos relacionados

Si quieres practicar pruebas con un proyecto completo, el curso de Java intermedio dedica un bloque a JUnit y Mockito.

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo