====== 05 - Test ======
Una funcionalidad CRUD puede parecer correcta mientras la desarrollamos y, sin embargo, fallar al guardar datos, responder por HTTP o completar el recorrido desde la interfaz. Las pruebas ayudan a detectar estos problemas y a comprobar que los cambios futuros no rompan lo que ya funcionaba.
En este proyecto trabajamos con una interfaz HTML, CSS y TypeScript, una API REST en Java con Spring Boot y servicios locales como MariaDB y MinIO, gestionados con Docker Compose. No todas las pruebas necesitan arrancar todo el sistema: elegir el alcance adecuado permite obtener comprobaciones más rápidas y fáciles de entender.
===== 1. Qué aporta una prueba =====
Una **prueba de software** ejecuta una comprobación definida y compara el resultado obtenido con el esperado. Una prueba útil debe dejar claro qué comportamiento verifica y debe poder repetirse en condiciones controladas.
Las pruebas permiten:
* **Detectar errores pronto**, antes de que se acumulen en otras partes del sistema.
* **Prevenir regresiones**: un cambio no debería romper comportamientos que ya estaban comprobados.
* **Describir el comportamiento esperado** con ejemplos concretos.
* **Facilitar los cambios**: una prueba rápida puede avisar si una modificación ha alterado algo importante.
Una prueba no demuestra que el programa esté libre de errores. Comprueba únicamente los casos que hemos planteado. Por eso importa tanto seleccionar casos representativos como mantener las pruebas sencillas y comprensibles.
==== 1.1 Independencia y determinismo ====
Un conjunto de pruebas fiable procura que cada prueba:
* Pueda ejecutarse sin depender del orden en que se ejecutan las demás.
* Prepare sus propios datos y deje el sistema en un estado conocido.
* No dependa de valores cambiantes, servicios externos inestables o esperas innecesarias.
* Dé un resultado repetible: las mismas condiciones deberían producir el mismo resultado.
Una prueba que pasa unas veces y falla otras sin cambios en el código se denomina **inestable**. Puede deberse, por ejemplo, a datos compartidos, orden de ejecución o dependencias que no se han controlado.
===== 2. Tipos de pruebas =====
Los tipos de pruebas se diferencian por aquello que comprueban y por el alcance del sistema que necesitan. Ninguno sustituye por completo a los demás.
^ Tipo ^ Qué comprueba ^ Dependencias habituales ^
| Unitaria | Una clase o comportamiento pequeño de forma aislada | Ningún servicio local; dependencias simuladas cuando corresponda |
| De arquitectura | Reglas sobre la estructura del código y sus dependencias | Código del proyecto; normalmente no necesita servicios |
| De integración | La colaboración entre el código Java y MariaDB, incluidos SQL y mapeos | Una base de datos de prueba, por ejemplo con Testcontainers |
| De API | Las respuestas HTTP de la API REST | API en ejecución y los servicios que esta necesite |
| E2E | Un recorrido completo desde la interfaz en el navegador | Interfaz, API y los servicios requeridos por el recorrido |
==== 2.1 Pruebas unitarias: JUnit 5 y Mockito ====
Una **prueba unitaria** comprueba una unidad pequeña de comportamiento, habitualmente un método o una clase. Se ejecuta rápidamente y evita depender de servicios externos.
* **JUnit 5** permite organizar y ejecutar pruebas Java.
* **Mockito** permite crear dobles de prueba —objetos simulados— para controlar las dependencias de la unidad comprobada.
El patrón **AAA** ayuda a ordenar cada prueba:
- **Arrange (preparar):** se crean los datos y se establece el comportamiento de las dependencias.
- **Act (actuar):** se ejecuta el comportamiento que se quiere comprobar.
- **Assert (verificar):** se compara el resultado con el esperado.
En un servicio que crea un producto, por ejemplo, una prueba unitaria podría preparar un producto y simular el repositorio, llamar al servicio y comprobar que el resultado es correcto y que el repositorio recibe la operación esperada. No necesita guardar datos en una MariaDB real.
**Aislar no significa simularlo todo.** Se simulan las dependencias externas a la unidad que dificultarían controlar la prueba; el comportamiento propio que queremos comprobar debe ejecutarse de verdad.
Una prueba unitaria resulta apropiada para reglas como:
* Validar los datos recibidos por un servicio.
* Calcular un valor derivado.
* Decidir qué respuesta dar ante un caso concreto.
* Comprobar qué interacción se solicita a una dependencia.
==== 2.2 Pruebas de arquitectura: ArchUnit ====
Las **pruebas de arquitectura** comprueban reglas sobre la organización del código. No verifican que un método devuelva el valor correcto: verifican que el proyecto respete decisiones estructurales.
Con **ArchUnit** se pueden expresar, entre otras, reglas como:
* El código de una capa no debe acceder directamente a otra capa no permitida.
* Los módulos o paquetes acordados no deben formar ciclos de dependencias.
* Ciertas clases deben seguir convenciones de nombres o ubicación.
Estas comprobaciones ayudan a evitar que el código pierda su organización a medida que crece. Por ejemplo, si el proyecto separa controladores, servicios y repositorios, una regla puede comprobar que los controladores no accedan directamente a los repositorios cuando la arquitectura prevista indica pasar por los servicios.
Son pruebas sobre el código del proyecto y, en general, no requieren arrancar MariaDB, MinIO ni el resto de servicios locales.
==== 2.3 Pruebas de integración: Testcontainers y MariaDB ====
Una **prueba de integración** comprueba que varias partes colaboran correctamente. En este proyecto, un caso importante es comprobar que el acceso a datos Java funciona con una MariaDB real, no solo con una dependencia simulada.
Con **Testcontainers**, las pruebas pueden disponer de una base de datos MariaDB aislada para comprobar aspectos como:
* Que las consultas SQL funcionan.
* Que las operaciones de creación, lectura, actualización y borrado guardan o recuperan los datos esperados.
* Que las restricciones de la base de datos se aplican.
* Que el mapeo entre filas de la base de datos y objetos Java es correcto.
Estas pruebas se centran en la integración entre el código de persistencia y la base de datos. No son pruebas de API: no comprueban por sí mismas las respuestas HTTP de los controladores.
MariaDB puede ejecutarse en un contenedor de prueba separado del entorno de desarrollo local de Docker Compose. Así se reduce el riesgo de modificar datos de desarrollo. Al ejecutar este tipo de pruebas, el entorno debe poder iniciar los contenedores que necesite Testcontainers.
==== 2.4 Pruebas de API: Playwright Java sin navegador ====
Una **prueba de API** envía peticiones HTTP a la API REST y comprueba las respuestas sin recorrer la interfaz gráfica. Puede verificar:
* El código de estado HTTP.
* El contenido JSON devuelto.
* Que una operación CRUD produce el efecto esperado cuando se consulta de nuevo.
En este proyecto se propone Playwright para Java con ''APIRequestContext'', una modalidad de Playwright que permite realizar peticiones HTTP **sin arrancar un navegador**. En ED se estudia principalmente Playwright para las pruebas E2E; esta modalidad de API no se enseña explícitamente y se introduce aquí como una aplicación directa de la misma herramienta.
Una comprobación de API puede seguir este esquema:
- Enviar una petición a un endpoint de la API.
- Comprobar el estado HTTP.
- Leer y comprobar el JSON de respuesta.
Para que la API responda, el backend debe estar en ejecución y configurado con los servicios que necesite. La base de datos, por tanto, puede ser necesaria para una operación CRUD real. La interfaz y el navegador no son necesarios. Si se accede a la API a través de una ruta de nginx, ese servicio también formará parte del entorno requerido; si se llama directamente al backend, no necesariamente.
Las direcciones, puertos y preparación del entorno dependen de la configuración acordada para el proyecto. Aquí no se fija un comando concreto para ejecutar estas pruebas.
==== 2.5 Pruebas E2E: Playwright con navegador ====
Una prueba **end-to-end (E2E)** recorre el sistema desde el punto de vista de quien lo usa, normalmente mediante un navegador. Puede, por ejemplo, abrir una página, completar un formulario y comprobar que el resultado aparece en la interfaz.
Una prueba E2E puede verificar que varias piezas funcionan juntas:
* La interfaz HTML, CSS y TypeScript.
* La comunicación entre la interfaz y la API REST.
* El backend y, cuando el recorrido lo requiere, sus servicios de datos.
Al usar Playwright con navegador, la prueba debe iniciar y controlar un navegador. Además, los servicios necesarios para el recorrido —por ejemplo, la interfaz, el backend y MariaDB— tienen que estar disponibles. nginx también puede ser necesario si el recorrido se realiza a través de él.
Las E2E dan confianza sobre recorridos completos, pero suelen necesitar más preparación que las pruebas unitarias. Por eso conviene cubrir con ellas los recorridos importantes, no repetir mediante el navegador cada pequeño caso que ya se puede verificar de forma más sencilla.
MinIO solo es necesario para una prueba cuyo comportamiento utilice el almacenamiento de objetos; no es una dependencia automática de cualquier prueba del proyecto.
===== 3. TDD: Rojo–Verde–Refactor =====
**TDD (desarrollo guiado por pruebas)** es un ciclo de trabajo, no una categoría adicional de prueba. Consiste en usar una prueba como guía mientras se desarrolla una funcionalidad:
- **Rojo:** escribir una prueba para un comportamiento que aún no está implementado y comprobar que falla.
- **Verde:** escribir el código mínimo necesario para que la prueba pase.
- **Refactor:** mejorar el diseño sin cambiar el comportamiento, comprobando que las pruebas siguen pasando.
Por ejemplo, al añadir una regla de validación a un servicio CRUD, primero se define un caso válido y otro inválido. Se implementa la regla para satisfacerlos y, después, se ordena el código sin alterar los resultados.
El ciclo puede aplicarse a una prueba unitaria y formar parte del trabajo con otros tipos de pruebas. No obliga a que toda la funcionalidad se diseñe únicamente desde pruebas, pero invita a concretar el comportamiento esperado antes de darlo por terminado.
===== 4. Elegir el tipo de prueba =====
Para decidir qué prueba escribir, hay que preguntarse qué riesgo se quiere comprobar y qué alcance mínimo basta para hacerlo.
* Si el riesgo está en una regla de negocio pequeña, empieza por una **prueba unitaria**.
* Si el riesgo está en que el código incumpla la organización acordada, usa una **prueba de arquitectura**.
* Si el riesgo está en SQL, restricciones, persistencia o mapeo, usa una **prueba de integración** con MariaDB.
* Si el riesgo está en el contrato HTTP —estado o JSON—, usa una **prueba de API**.
* Si el riesgo está en que una persona no pueda completar un recorrido desde la interfaz, usa una **prueba E2E**.
Un mismo comportamiento puede necesitar más de una comprobación. Por ejemplo, crear un producto puede requerir una prueba unitaria para la validación, una prueba de integración para su persistencia y una prueba E2E para comprobar el formulario. Cada prueba comprueba un aspecto distinto.
==== 4.1 Qué servicios locales necesita cada prueba ====
^ Prueba ^ ¿Necesita navegador? ^ ¿Puede necesitar Compose u otros servicios locales? ^
| Unitaria | No | Normalmente no |
| De arquitectura | No | Normalmente no |
| Integración con MariaDB | No | Necesita una base de datos de prueba; Testcontainers puede iniciarla en un contenedor |
| API | No | Sí, si el backend requiere MariaDB u otros servicios |
| E2E | Sí | Sí, según el recorrido y la forma de acceder a la aplicación |
No es necesario arrancar todos los servicios para cada prueba. Conviene identificar qué partes usa el caso concreto y mantener aislado el entorno de pruebas de los datos de desarrollo.
===== 5. Flujo gradual para una funcionalidad CRUD =====
Supongamos que se añade una funcionalidad para crear y consultar productos. Se puede avanzar de las comprobaciones más acotadas a las que recorren más componentes:
- **Definir el comportamiento.** Concretar qué datos acepta la operación, qué ocurre cuando falta un dato y qué resultado debe obtenerse al crear o consultar un producto.
- **Comprobar la regla de forma unitaria.** Usar JUnit 5 y, si el servicio colabora con un repositorio u otra dependencia, Mockito para controlarla.
- **Comprobar la arquitectura.** Verificar con ArchUnit que las clases nuevas siguen las reglas de capas, dependencias, ciclos y convenciones del proyecto.
- **Comprobar la persistencia.** Usar Testcontainers con MariaDB para verificar SQL, restricciones y mapeos con datos de prueba controlados.
- **Comprobar el contrato HTTP.** Enviar una petición mediante ''APIRequestContext'' y comprobar el estado y el JSON de la API en ejecución.
- **Comprobar el recorrido de usuario.** Usar Playwright con navegador para crear o consultar el producto desde la interfaz y verificar lo que se muestra.
El flujo puede adaptarse al cambio. Una modificación de estilo puede no requerir una prueba de persistencia; una nueva consulta SQL sí puede requerir la prueba de integración aunque no cambie el recorrido de usuario.
Las pruebas Java se pueden ejecutar con ''mvn test''. Para Playwright Java no se fija aquí un comando concreto: su ejecución depende de la configuración del proyecto.
===== 6. Buenas prácticas y errores frecuentes =====
* **Escribe pruebas independientes.** Una prueba debe preparar sus datos, no depender de que otra se ejecute antes.
* **Controla los datos.** Usa valores conocidos y evita reutilizar información que pueda cambiar entre ejecuciones.
* **Busca determinismo.** Si una prueba falla de forma intermitente, investiga la causa en lugar de repetirla hasta que pase.
* **Comprueba comportamientos, no detalles accidentales.** Una prueba demasiado ligada a la implementación puede fallar aunque el comportamiento siga siendo correcto.
* **Elige el alcance adecuado.** No hace falta arrancar todo Compose para probar una regla unitaria; tampoco basta con simular el repositorio para confirmar que una consulta SQL funciona en MariaDB.
* **Mantén claras las responsabilidades.** Una prueba de API verifica el contrato HTTP; una prueba E2E comprueba un recorrido con navegador; una prueba de integración con MariaDB verifica persistencia y acceso a datos.
* **Usa las pruebas como protección frente a regresiones.** Cuando se corrige un fallo, añade una comprobación que permita detectar si vuelve a aparecer.
* **Lee las pruebas generadas con IA.** La IA puede ayudar a proponer casos y escribir código de prueba, pero quien lo entrega debe comprender qué prepara, qué ejecuta y qué verifica cada prueba.
===== 7. Referencias =====
* Introducción a testing en ED: [[clase:daw:ed:testing|Introducción a testing en ED]]
* JUnit 5 y Mockito: [[clase:daw:ed:unitarias|JUnit 5 y Mockito]]
* ArchUnit: [[clase:daw:ed:arquitectura|ArchUnit]]
* Playwright E2E: [[clase:daw:ed:e2e|Playwright E2E]]
* Testcontainers: [[clase:daw:ed:integracion|Testcontainers]]
* TDD: [[clase:daw:ed:tdd|TDD]]
* Git en el proyecto de 1.º DAW: [[clase:daw:proyecto-1daw:tema03|Git en el proyecto de 1.º DAW]]
* Build y despliegue local: [[clase:daw:proyecto-1daw:tema04|Build y despliegue local]]