Gruki Logo

Gruki - Documentación de Programación

Java

JUnit y Mockito: Probando tu código Java como un superhéroe

Aprende a usar JUnit y Mockito para crear pruebas unitarias robustas en Java. Simplificamos los conceptos para que sean fáciles de entender, incluso para principiantes.

Imagínate que estás construyendo una torre de Lego. Antes de poner una pieza encima de otra, quieres asegurarte de que cada pieza por separado está perfecta, ¿verdad? JUnit y Mockito te ayudan a hacer eso mismo con tu código Java. Son como tus ayudantes de Lego, asegurándose de que cada 'pieza' (cada parte de tu código) funciona correctamente por sí sola.

JUnit es como un 'revisor'. Le dices qué esperas que haga tu código, y él comprueba si realmente lo hace. Mockito, por otro lado, es como un 'actor de doblaje'. A veces, una pieza de tu código necesita de otra pieza para funcionar, pero aún no está lista o es difícil de probar. Mockito crea 'falsos' de esas piezas para que puedas probar la primera sin problemas. Así, puedes probar cada parte de tu código de forma aislada.

JUnit: El revisor de tu código

JUnit te permite escribir pequeñas pruebas que verifican si tu código se comporta como esperas. Es como un examen para cada pequeña parte de tu programa.

Imagina que tienes una función que suma dos números. JUnit te permite escribir una prueba que diga: 'Si le doy a esta función 2 y 3, espero que me devuelva 5'. JUnit ejecuta la función con esos números y verifica si realmente devuelve 5. Si no, ¡te avisa para que puedas corregir el problema!

Puntos importantes:

  • Anotaciones: JUnit usa 'anotaciones' (palabras con un @ al principio) para indicar qué son las pruebas. Por ejemplo, `@Test` significa que ese método es una prueba.
  • Afirmaciones: Dentro de las pruebas, usas 'afirmaciones' (como `assertEquals`) para decir qué esperas que ocurra. `assertEquals(5, miFuncion(2, 3))` significa: 'Estoy afirmando que `miFuncion(2, 3)` debe ser igual a 5'.

Mockito: El actor de doblaje para pruebas

Mockito te permite crear 'mocks' (objetos falsos) de otras partes de tu código. Esto es útil cuando una parte depende de otra que aún no está lista, es difícil de probar o se comporta de manera impredecible.

Imagina que tu código necesita leer datos de una base de datos. Probar directamente con la base de datos puede ser lento e incluso peligroso (¡podrías borrar datos sin querer!). Mockito te permite crear un 'mock' de la base de datos. Este 'mock' finge ser la base de datos y le da a tu código las respuestas que esperas, sin tocar la base de datos real.

Puntos importantes:

  • Creación de mocks: Mockito te permite crear mocks fácilmente con `Mockito.mock(ClaseACrearMock.class)`. Esto crea un objeto falso que se comporta como la clase que le indicas.
  • Comportamiento definido: Puedes decirle al mock cómo debe comportarse cuando se llama a sus métodos. Por ejemplo, `when(miMock.obtenerDato()).thenReturn("dato_falso")` dice: 'Cuando se llame a `obtenerDato()` en `miMock`, devuelve `dato_falso`'.

Ejemplos de Código

Ejemplo sencillo de una prueba JUnit con Mockito. Probamos una clase 'Calculadora' que usa otra clase 'ServicioExterno' para obtener un valor.

Lenguaje: Java

Explicación del código:

  1. Línea 1: Línea 1-3: Importamos las librerías de JUnit y Mockito que necesitamos.
  2. Línea 2: Línea 5-15: Definimos la clase `Calculadora`. Esta clase usa un `ServicioExterno` para obtener un valor y sumarlo a un número. Imagina que el `ServicioExterno` es como un amigo que te da un caramelo para que lo sumes a los que ya tienes.
  3. Línea 3: Línea 17-19: Definimos una interfaz `ServicioExterno` con un método `obtenerValor()`. Esta interfaz representa el servicio externo que la Calculadora necesita. Es como decirle a tu amigo: 'Quiero un caramelo, no importa de qué sabor'.
  4. Línea 4: Línea 21-38: Definimos la clase de prueba `CalculadoraTest`. Aquí es donde escribimos la prueba para la Calculadora.
  5. Línea 5: Línea 22: `@Test` indica que este método (`testCalcular()`) es una prueba.
  6. Línea 6: Línea 24: `ServicioExterno servicioMock = Mockito.mock(ServicioExterno.class);` Aquí creamos un 'mock' del `ServicioExterno` usando Mockito. Es como crear una copia falsa de tu amigo que te da caramelos.
  7. Línea 7: Línea 27: `when(servicioMock.obtenerValor()).thenReturn(10);` Aquí le decimos al 'mock' que cuando se llame al método `obtenerValor()`, devuelva 10. Es como decirle a la copia falsa de tu amigo: 'Cuando te pida un caramelo, dame uno que vale 10 puntos'.
  8. Línea 8: Línea 30: `Calculadora calculadora = new Calculadora(servicioMock);` Creamos una instancia de la clase `Calculadora`, pasándole el 'mock' del `ServicioExterno`. Es como usar la copia falsa de tu amigo para calcular cuántos caramelos tienes en total.
  9. Línea 9: Línea 33: `int resultado = calculadora.calcular(5);` Llamamos al método `calcular()` de la `Calculadora` con el número 5. Es como preguntarle a la calculadora: '¿Cuánto es 5 más el caramelo que me da mi amigo falso?'
  10. Línea 10: Línea 36: `assertEquals(15, resultado);` Usamos `assertEquals()` para verificar que el resultado es 15. Es como comprobar si la calculadora ha hecho bien la suma: '¿Es verdad que 5 más 10 (el caramelo falso) son 15?'

Recursos relacionados

Explora más contenido relacionado con Uso de JUnit y Mockito. para profundizar tus conocimientos.