Primeros tests

Código Completo

El resultado final del código desarrollado en este documento se puede encontrar en el monorepo de GitHub springboot-demo-projects, en el/los commit(s) Testing Java, Testing Kotlin, Testing Groovy.

Estrategia de testing

Elegí un framework

• Para la aplicación Java Spring Boot vamos a elegir JUnit + Mockito: es el estándar de facto, el que siempre preguntan en entrevistas, y el que se espera que conozcas.
• Para la aplicación Kotlin Spring Boot vamos a elegir JUnit + MockK: herramientas nativas de kotlin + mocking pensado para kotlin.
• Para el proyecto Groovy Spring Boot vamos a elegir Spock, ya que es la elección natural con menos esfuerzo.

JaCoCo

JaCoCo (Java Code Coverage) te dice qué líneas de código tus tests realmente ejecutan. Es la herramienta estándar de cobertura para proyectos JVM.

Cuando corrés la tarea test o jacocoTestReport, JaCoCo va a generar reportes en HTML (para humanos) y XML (para herramientas de CI) en build/reports/jacoco/test.

Qué archivos testear

¿Debo crear una prueba por cada archivo de paquete principal? ¿Puedo agrupar las pruebas? ¿Qué tipo de prueba es mejor? Ninguna de estas preguntas tiene una única respuesta definitiva. Varía según el equipo y el desarrollador. Aquí comparto mi enfoque; sentite libre de seguirlo, adaptarlo y modificarlo según sea necesario.

Dado un proyecto CRUD REST + Base de datos con arquitectura hexagonal:

• Las clases relacionadas con Adapter In que adaptan REST se pueden agrupar y probar juntas bajo una prueba de segmento de capa web @WebMvcTest.
• Las clases relacionadas con Adapter Out que adaptan JPA se pueden agrupar y probar juntas bajo una prueba de segmento de capa JPA @DataJpaTest.
• Las implementaciones de casos de uso de dominio se pueden agrupar y probar juntas bajo una prueba unitaria.
• Las clases de Configuración son complicadas. La mayoría de los equipos simplemente las ignoran. Mi opinión al respecto es la siguiente:
  • Las clases web @RestControllerAdvice se prueban con una prueba MockMvc Standalone de segmento de capa web @WebMvcTest.
  • He visto a desarrolladores probar clases relacionadas con logs en pruebas de integración. Mi opinión es evitar probar filtros y aspectos relacionados con logs. Demasiado esfuerzo para tan poco beneficio.

◀─────────────────── ESPECTRO DE PRUEBAS ───────────────────▶

UNITARIO                                            INTEGRACIÓN
RÁPIDO                                                    LENTO
AISLADO                                               CONECTADO

⚪──────────⚪──────────⚪──────────⚪
 │           │           │           │
 │           │           │           └── Spring Boot Completo
 │           │           └── Solo Capa Web
 │           └── MockMvc Independiente
 └── Prueba Unitaria Pura

Archivos a Crear/Modificar

Java

File Tree

.
├── build.gradle
├── ...
└── src
    ├── main
    │   └── java
    │       └── dev
    │           └── pollito
    │               └── spring_java
    │                   ├── config
    │                   │   └── web
    │                   │       └── ControllerAdvice.java
    │                   └── ...
    └── test
        ├── java
        │   └── dev
        │       └── pollito
        │           └── spring_java
        │               ├── common
        │               │   └── util
        │               │       └── EnumUtilsTest.java
        │               ├── config
        │               │   └── web
        │               │       └── ControllerAdviceMockMvcTest.java
        │               └── sakila
        │                   └── film
        │                       ├── adapter
        │                       │   └── in
        │                       │       └── rest
        │                       │           └── FilmRestControllerMockMvcTest.java
        │                       └── domain
        │                           └── service
        │                               └── FilmUseCasesImplTest.java
        └── util
            └── MockMvcResultMatchers.java

Kotlin

File Tree

.
├── build.gradle.kts
├── ...
└── src
    ├── main
    │   └── kotlin
    │       └── dev
    │           └── pollito
    │               └── spring_kotlin
    │                   ├── config
    │                   │   └── web
    │                   │       └── ControllerAdvice.kt
    │                   └── ...
    └── test
        ├── kotlin
        │   └── dev
        │       └── pollito
        │           └── spring_kotlin
        │               ├── common
        │               │   └── util
        │               │       └── EnumUtilsTest.kt
        │               ├── config
        │               │   └── web
        │               │       └── ControllerAdviceMockMvcTest.kt
        │               └── sakila
        │                   └── film
        │                       ├── adapter
        │                       │   └── in
        │                       │       └── rest
        │                       │           └── FilmRestControllerMockMvcTest.kt
        │                       └── domain
        │                           └── service
        │                               └── FilmUseCasesImplTest.kt
        └── util
            └── MockMvcResultMatchersDsl.kt

Groovy

File Tree

.
├── build.gradle
├── ...
└── src
    ├── main
    │   └── groovy
    │       └── dev
    │           └── pollito
    │               └── spring_groovy
    │                   ├── config
    │                   │   └── web
    │                   │       └── ControllerAdvice.groovy
    │                   └── ...
    └── test
        ├── groovy
        │   └── dev
        │       └── pollito
        │           └── spring_groovy
        │               ├── common
        │               │   └── util
        │               │       └── EnumUtilsSpec.groovy
        │               ├── config
        │               │   └── web
        │               │       └── ControllerAdviceMockMvcSpec.groovy
        │               └── sakila
        │                   └── film
        │                       ├── adapter
        │                       │   └── in
        │                       │       └── rest
        │                       │           └── FilmRestControllerMockMvcSpec.groovy
        │                       └── domain
        │                           └── service
        │                               └── FilmUseCasesImplSpec.groovy
        └── util
            └── MockMvcResultMatchersTrait.groovy

Dependencias

Java

build.gradle (plugin block)

  id 'jacoco'

build.gradle (new jacoco blocks + updated test block)

jacoco {
  toolVersion = "0.8.14"
}

jacocoTestReport {
  dependsOn test
  reports {
    xml.required = true
    html.required = true
  }

  classDirectories.setFrom(
      files(classDirectories.files.collect {
        fileTree(it) {
          exclude(
              // Generated code
              '**/generated/**',
              '**/openapitools/**',

              // Application entry point
              '**/*Application*',

              // Domain models (POJOs)
              '**/domain/model/**',

              // Log
              '**/log/**',

              // MapStruct
              '**/*MapperImpl*',
              )
        }
      })
      )
}

jacocoTestCoverageVerification {
  dependsOn jacocoTestReport
  classDirectories.setFrom(jacocoTestReport.classDirectories)
  violationRules {
    rule {
      limit {
        counter = 'LINE'
        minimum = 0.8
      }
      limit {
        counter = 'BRANCH'
        minimum = 0.5
      }
    }
  }
}

tasks.named('check') {
  dependsOn jacocoTestCoverageVerification
}

tasks.named('test') {
  useJUnitPlatform()
  jvmArgs '-XX:+EnableDynamicAgentLoading'
  jvmArgumentProviders.add({
    def mockitoAgent = configurations.testRuntimeClasspath.resolvedConfiguration
        .resolvedArtifacts
        .find { it.name == 'mockito-core' }
        ?.file
    mockitoAgent ? ["-javaagent:${mockitoAgent}"] : []
  } as CommandLineArgumentProvider)
  finalizedBy jacocoTestReport
}

Kotlin

build.gradle.kts (plugin block)

  jacoco

build.gradle.kts (dependencies block)

  testImplementation("com.ninja-squad:springmockk:5.0.1")
  testImplementation("io.mockk:mockk:1.14.9")

build.gradle.kts (updated test block + new jacoco blocks)

tasks.withType<Test> {
  useJUnitPlatform()
  jvmArgs("-XX:+EnableDynamicAgentLoading", "-Xshare:off")
  finalizedBy(tasks.jacocoTestReport)
}

jacoco { toolVersion = "0.8.14" }

tasks.jacocoTestReport {
  dependsOn(tasks.test)
  reports {
    xml.required.set(true)
    html.required.set(true)
  }

  classDirectories.setFrom(
      files(
          classDirectories.files.map {
            fileTree(it) {
              exclude(
                  // Generated code
                  "**/generated/**",
                  "**/openapitools/**",

                  // log
                  "**/log/**",

                  // Application entry point
                  "**/*Application*",

                  // Domain models (POJOs)
                  "**/domain/model/**",

                  // MapStruct
                  "**/*MapperImpl*",
              )
            }
          }
      )
  )
}

tasks.jacocoTestCoverageVerification {
  dependsOn(tasks.jacocoTestReport)

  violationRules {
    rule {
      limit {
        counter = "LINE"
        minimum = "0.8".toBigDecimal()
      }
      limit {
        counter = "BRANCH"
        minimum = "0.5".toBigDecimal()
      }
    }
  }

  classDirectories.setFrom(tasks.jacocoTestReport.get().classDirectories)
}

tasks.named("check") { dependsOn(tasks.jacocoTestCoverageVerification) }

Groovy

build.gradle (plugin block)

  id 'jacoco'

build.gradle (dependencies block)

  testImplementation 'org.spockframework:spock-core:2.4-groovy-5.0'
  testImplementation 'org.spockframework:spock-spring:2.4-groovy-5.0'

build.gradle (updated test block + new jacoco blocks)

configurations.testImplementation {
  exclude group: 'org.mockito'
}

tasks.named('test') {
  useJUnitPlatform()
  finalizedBy jacocoTestReport
}

jacoco {
  toolVersion = "0.8.14"
}

jacocoTestReport {
  dependsOn test
  reports {
    xml.required = true
    html.required = true
  }

  classDirectories.setFrom(
      files(classDirectories.files.collect {
        fileTree(it) {
          exclude(
              // Generated code
              '**/generated/**',
              '**/openapitools/**',

              // Groovy Internal Artifacts
              '**/*$*_closure*',
              '**/*__*$*',
              '**/*__*',

              // Log
              '**/log/**',

              // Application entry point
              '**/*Application*',

              // Domain models (POJOs)
              '**/domain/model/**',

              // ModelMapper
              '**/config/mapper/**',
              )
        }
      })
      )
}

jacocoTestCoverageVerification {
  dependsOn jacocoTestReport
  classDirectories.setFrom(jacocoTestReport.classDirectories)
  violationRules {
    rule {
      limit {
        counter = 'LINE'
        minimum = 0.8
      }
    }
  }
}

tasks.named('check') {
  dependsOn jacocoTestCoverageVerification
}

Tests unitarios

Los tests unitarios no involucran a Spring en absoluto. Estos son más rápidos de correr y perfectos para testear lógica de negocio en completo aislamiento.

Manténlo real

Los tests mostrados aquí son intencionalmente simples. Demuestran el cableado y aserciones básicas, no una validación exhaustiva. Qué tan profundo vas con el testing es, en última instancia, una filosofía de equipo (y de cada desarrollador). Es muy fácil escribir tests triviales que pinten cada línea de verde en un reporte de JaCoCo sin realmente probar nada significativo. Trata la cobertura como una guía, no como un objetivo.

Test de la implementación de los casos de uso

FilmUseCasesImpl.getFilm() actualmente solo devuelve una película hardcodeada. No tiene mucho sentido hacer testing profundo acá todavía, pero al menos verifiquemos que el servicio se instancie y devuelva algo:

Java

java/dev/pollito/spring_java/sakila/film/domain/service/FilmUseCasesImplTest.java

package dev.pollito.spring_java.sakila.film.domain.service;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;

@ExtendWith(MockitoExtension.class)
class FilmUseCasesImplTest {
  @InjectMocks private FilmUseCasesImpl useCases;

  @Test
  void getFilmReturnsADomainModel() {
    assertNotNull(useCases.getFilm(1));
  }
}

Kotlin

kotlin/dev/pollito/spring_kotlin/sakila/film/domain/service/FilmUseCasesImplTest.kt

package dev.pollito.spring_kotlin.sakila.film.domain.service

import io.mockk.impl.annotations.InjectMockKs
import io.mockk.junit5.MockKExtension
import kotlin.test.Test
import kotlin.test.assertNotNull
import org.junit.jupiter.api.extension.ExtendWith

@ExtendWith(MockKExtension::class)
class FilmUseCasesImplTest {
  @InjectMockKs private lateinit var useCases: FilmUseCasesImpl

  @Test
  fun `getFilm returns a domain model`() {
    assertNotNull(useCases.getFilm(1))
  }
}

Groovy

groovy/dev/pollito/spring_groovy/sakila/film/domain/service/FilmUseCasesImplSpec.groovy

package dev.pollito.spring_groovy.sakila.film.domain.service

import spock.lang.Specification
import spock.lang.Subject

class FilmUseCasesImplSpec extends Specification {
  @Subject FilmUseCasesImpl useCases = new FilmUseCasesImpl()

  def "getFilm returns a domain model"() {
    when: "getFilm is called"
    def result = useCases.getFilm(1)

    then: "a domain model is returned"
    result != null
  }
}

Test de la utilidad Enum

Java

java/dev/pollito/spring_java/common/util/EnumUtilsTest.java

package dev.pollito.spring_java.common.util;

import static dev.pollito.spring_java.common.util.EnumUtils.fromValue;
import static org.junit.jupiter.api.Assertions.*;

import dev.pollito.spring_java.common.ValuedEnum;
import org.junit.jupiter.api.Test;

class EnumUtilsTest {

  private enum Color implements ValuedEnum<String> {
    RED("red"),
    GREEN("green"),
    BLUE("blue");

    private final String value;

    Color(String value) {
      this.value = value;
    }

    @Override
    public String getValue() {
      return value;
    }
  }

  @Test
  void fromValue_returnsMatchingConstant() {
    assertEquals(Color.RED, fromValue(Color.class, "red"));
    assertEquals(Color.GREEN, fromValue(Color.class, "green"));
    assertEquals(Color.BLUE, fromValue(Color.class, "blue"));
  }

  @Test
  void fromValue_throwsIllegalArgumentExceptionForUnknownValue() {
    IllegalArgumentException ex =
        assertThrows(IllegalArgumentException.class, () -> fromValue(Color.class, "yellow"));
    assertTrue(ex.getMessage().contains("Color"));
    assertTrue(ex.getMessage().contains("yellow"));
  }
}

Kotlin

kotlin/dev/pollito/spring_kotlin/common/util/EnumUtilsTest.kt

package dev.pollito.spring_kotlin.common.util

import dev.pollito.spring_kotlin.common.ValuedEnum
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Test

class EnumUtilsTest {

  private enum class Color(private val code: String) : ValuedEnum<String> {
    RED("red"),
    GREEN("green"),
    BLUE("blue");

    override fun getValue(): String = code
  }

  private enum class Priority(private val level: Int) : ValuedEnum<Int> {
    LOW(1),
    MEDIUM(2),
    HIGH(3);

    override fun getValue(): Int = level
  }

  @Test
  fun `fromValue returns correct enum constant for matching string value`() {
    val result = EnumUtils.fromValue(Color::class.java, "green")
    assertEquals(Color.GREEN, result)
  }

  @Test
  fun `fromValue returns correct enum constant for matching int value`() {
    val result = EnumUtils.fromValue(Priority::class.java, 3)
    assertEquals(Priority.HIGH, result)
  }

  @Test
  fun `fromValue returns first constant when value matches first entry`() {
    val result = EnumUtils.fromValue(Color::class.java, "red")
    assertEquals(Color.RED, result)
  }

  @Test
  fun `fromValue throws IllegalArgumentException for unknown value`() {
    val exception =
        assertThrows(IllegalArgumentException::class.java) {
          EnumUtils.fromValue(Color::class.java, "yellow")
        }
    assertEquals("Unknown Color value: yellow", exception.message)
  }

  @Test
  fun `fromValue exception message includes the enum class name`() {
    val exception =
        assertThrows(IllegalArgumentException::class.java) {
          EnumUtils.fromValue(Priority::class.java, 99)
        }
    assertEquals("Unknown Priority value: 99", exception.message)
  }
}

Groovy

groovy/dev/pollito/spring_groovy/common/util/EnumUtilsSpec.groovy

package dev.pollito.spring_groovy.common.util

import dev.pollito.spring_groovy.common.ValuedEnum
import spock.lang.Specification

class EnumUtilsSpec extends Specification {

  private enum Color implements ValuedEnum<String> {
    RED("red"),
    GREEN("green"),
    BLUE("blue")

    private final String value

    Color(String value) {
      this.value = value
    }

    @Override
    String getValue() {
      value
    }
  }

  def "fromValue returns the matching enum constant"() {
    expect:
    EnumUtils.fromValue(Color, "red") == Color.RED
    EnumUtils.fromValue(Color, "green") == Color.GREEN
    EnumUtils.fromValue(Color, "blue") == Color.BLUE
  }

  def "fromValue throws IllegalArgumentException for unknown value"() {
    when:
    EnumUtils.fromValue(Color, "yellow")

    then:
    IllegalArgumentException ex = thrown()
    ex.message.contains("Color")
    ex.message.contains("yellow")
  }
}

Slice Tests

Capa Web

Estamos testeando tres cosas acá:

• Comportamiento del endpoint REST: ¿El controller mapea requests correctamente y devuelve las respuestas esperadas?
• Manejo de excepciones: Cuando las cosas salen mal, ¿la estructura de respuesta de error se ve bien?
• Estructura de respuesta JSON: ¿El JSON final coincide con lo que promete nuestro contrato de API?

Para hacer nuestras aserciones más legibles, primero vamos a crear algunos matchers custom para la estructura de respuesta de nuestra API:

Java

java/dev/pollito/spring_java/test/util/MockMvcResultMatchers.java

package dev.pollito.spring_java.test.util;

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;

import org.springframework.http.HttpStatus;
import org.springframework.test.web.servlet.ResultMatcher;

public final class MockMvcResultMatchers {

  private MockMvcResultMatchers() {}

  public static ResultMatcher hasStandardApiResponseFields(
      String expectedInstance, HttpStatus expectedStatus) {
    return result -> {
      jsonPath("$.instance").value(expectedInstance).match(result);
      jsonPath("$.status").value(expectedStatus.value()).match(result);
      jsonPath("$.timestamp").exists().match(result);
      jsonPath("$.trace").exists().match(result);
    };
  }

  public static ResultMatcher hasErrorFields(HttpStatus expectedStatus) {
    return result -> jsonPath("$.title").value(expectedStatus.getReasonPhrase()).match(result);
  }
}

Kotlin

kotlin/dev/pollito/spring_kotlin/test/util/MockMvcResultMatchersDsl.kt

package dev.pollito.spring_kotlin.test.util

import org.springframework.http.HttpStatus
import org.springframework.test.web.servlet.MockMvcResultMatchersDsl

fun MockMvcResultMatchersDsl.hasStandardApiResponseFields(
    expectedInstance: String,
    expectedStatus: HttpStatus,
) {
  jsonPath("$.instance") { value(expectedInstance) }
  jsonPath("$.status") { value(expectedStatus.value()) }
  jsonPath("$.timestamp") { exists() }
  jsonPath("$.trace") { exists() }
}

fun MockMvcResultMatchersDsl.hasErrorFields(extectedStatus: HttpStatus) {
  jsonPath("$.title") { value(extectedStatus.reasonPhrase) }
}

Kotlin Extension Function

Al extender MockMvcResultMatchersDsl, nuestros matchers custom se integran perfectamente con el DSL de Kotlin de Spring. Se pueden llamar directamente dentro del bloque andExpect, haciendo que el código de test lea como una parte nativa del framework.

Groovy

groovy/dev/pollito/spring_groovy/test/util/MockMvcResultMatchersTrait.groovy

package dev.pollito.spring_groovy.test.util

import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath

import org.springframework.http.HttpStatus
import org.springframework.test.web.servlet.ResultMatcher

trait MockMvcResultMatchersTrait {

  ResultMatcher hasStandardApiResponseFields(String expectedInstance, HttpStatus expectedStatus) {
    { result ->
      jsonPath('$.instance').value(expectedInstance).match(result)
      jsonPath('$.status').value(expectedStatus.value()).match(result)
      jsonPath('$.timestamp').exists().match(result)
      jsonPath('$.trace').exists().match(result)
    } as ResultMatcher
  }

  ResultMatcher hasErrorFields(HttpStatus expectedStatus) {
    { result ->
      jsonPath('$.title').value(expectedStatus.reasonPhrase).match(result)
    } as ResultMatcher
  }
}

Groovy Trait

Un trait es como una interfaz con implementación que se puede mezclar en clases. Al implementar este trait en tus especificaciones Spock, los métodos matcher se vuelven disponibles como si estuvieran definidos directamente en tu clase de test, sin necesidad de imports estáticos. A diferencia de las clases base abstractas, podés implementar múltiples traits, manteniendo tu jerarquía de tests flexible.

Ahora escribamos el test del @RestController propiamente dicho usando un enfoque de slice testing con @WebMvcTest, que crea un contexto mínimo de Spring enfocado en la capa web.

Java

java/dev/pollito/spring_java/sakila/film/adapter/in/rest/FilmRestControllerMockMvcTest.java

package dev.pollito.spring_java.sakila.film.adapter.in.rest;

import static dev.pollito.spring_java.test.util.MockMvcResultMatchers.hasErrorFields;
import static dev.pollito.spring_java.test.util.MockMvcResultMatchers.hasStandardApiResponseFields;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.springframework.http.HttpStatus.*;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

import dev.pollito.spring_java.config.web.ControllerAdvice;
import dev.pollito.spring_java.sakila.film.domain.model.Film;
import dev.pollito.spring_java.sakila.film.domain.port.in.FilmUseCases;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpStatus;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.context.bean.override.mockito.MockitoSpyBean;
import org.springframework.test.web.servlet.MockMvc;

@WebMvcTest(FilmRestController.class)
@Import({ControllerAdvice.class, FilmRestMapperImpl.class})
class FilmRestControllerMockMvcTest {

  public static final String PATH = "/api/films";
  public static final String CONTENT_BODY =
      """
			{
				"title": "ACADEMY DINOSAUR",
				"language": "English",
				"rentalDuration": 3,
				"rentalRate": 4.99,
				"replacementCost": 20.99
			}
			""";

  @SuppressWarnings("unused")
  @Autowired
  private MockMvc mockMvc;

  @SuppressWarnings("unused")
  @MockitoBean
  private FilmUseCases filmUseCases;

  @SuppressWarnings("unused")
  @MockitoSpyBean
  private FilmRestMapper mapper;

  @Test
  void getFilmReturnsOK() throws Exception {
    Integer filmId = 1;
    Film film = mock(Film.class);
    when(film.getId()).thenReturn(filmId);

    when(filmUseCases.getFilm(anyInt())).thenReturn(film);

    mockMvc
        .perform(get(PATH + "/{id}", filmId).accept(APPLICATION_JSON))
        .andExpect(status().isOk())
        .andExpect(content().contentType(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields(PATH + "/" + filmId, OK));
  }

  @Test
  void getFilmsReturnsINTERNAL_SERVER_ERROR() throws Exception {
    HttpStatus status = INTERNAL_SERVER_ERROR;
    mockMvc
        .perform(get(PATH).accept(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields(PATH, status))
        .andExpect(hasErrorFields(status));
  }

  @Test
  void createFilmReturnsINTERNAL_SERVER_ERROR() throws Exception {
    HttpStatus status = INTERNAL_SERVER_ERROR;
    mockMvc
        .perform(
            post(PATH).contentType(APPLICATION_JSON).content(CONTENT_BODY).accept(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields(PATH, status))
        .andExpect(hasErrorFields(status));
  }

  @Test
  void deleteFilmReturnsINTERNAL_SERVER_ERROR() throws Exception {
    Integer filmId = 1;
    HttpStatus status = INTERNAL_SERVER_ERROR;
    mockMvc
        .perform(delete(PATH + "/{id}", filmId).accept(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields(PATH + "/" + filmId, status))
        .andExpect(hasErrorFields(status));
  }

  @Test
  void updateFilmReturnsINTERNAL_SERVER_ERROR() throws Exception {
    Integer filmId = 1;
    HttpStatus status = INTERNAL_SERVER_ERROR;
    mockMvc
        .perform(
            put(PATH + "/{id}", filmId)
                .contentType(APPLICATION_JSON)
                .content(CONTENT_BODY)
                .accept(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields(PATH + "/" + filmId, status))
        .andExpect(hasErrorFields(status));
  }
}

Kotlin

kotlin/dev/pollito/spring_kotlin/sakila/film/adapter/in/rest/FilmRestControllerMockMvcTest.kt

package dev.pollito.spring_kotlin.sakila.film.adapter.`in`.rest

import com.ninjasquad.springmockk.MockkBean
import dev.pollito.spring_kotlin.config.web.ControllerAdvice
import dev.pollito.spring_kotlin.sakila.film.domain.model.Film
import dev.pollito.spring_kotlin.sakila.film.domain.port.`in`.FilmUseCases
import dev.pollito.spring_kotlin.test.util.hasErrorFields
import dev.pollito.spring_kotlin.test.util.hasStandardApiResponseFields
import io.mockk.every
import io.mockk.mockk
import java.time.OffsetDateTime.now
import kotlin.test.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest
import org.springframework.context.annotation.Import
import org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR
import org.springframework.http.HttpStatus.OK
import org.springframework.http.MediaType.APPLICATION_JSON
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.delete
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.post
import org.springframework.test.web.servlet.put

@WebMvcTest(FilmRestController::class)
@Import(ControllerAdvice::class, FilmRestMapperImpl::class)
class FilmRestControllerMockMvcTest {
  companion object {
    private const val PATH = "/api/films"
    private const val CONTENT_BODY =
        """
            {
                "title": "ACADEMY DINOSAUR",
                "language": "English",
                "rentalDuration": 3,
                "rentalRate": 4.99,
                "replacementCost": 20.99
            }
        """
  }

  @MockkBean private lateinit var useCases: FilmUseCases
  @Autowired private lateinit var mockMvc: MockMvc

  @Test
  fun `getFilm returns OK`() {
    val filmId = 1
    val film = mockk<Film>(relaxed = true)
    every { film.lastUpdate } returns now()
    every { useCases.getFilm(filmId) } returns film

    mockMvc
        .get("$PATH/$filmId") { accept = APPLICATION_JSON }
        .andExpect {
          status { isOk() }
          hasStandardApiResponseFields("$PATH/$filmId", OK)
        }
  }

  @Test
  fun `getFilms returns INTERNAL_SERVER_ERROR`() {
    mockMvc
        .get(PATH) { accept = APPLICATION_JSON }
        .andExpect {
          status { isInternalServerError() }
          hasStandardApiResponseFields(PATH, INTERNAL_SERVER_ERROR)
          hasErrorFields(INTERNAL_SERVER_ERROR)
        }
  }

  @Test
  fun `createFilm returns INTERNAL_SERVER_ERROR`() {
    mockMvc
        .post(PATH) {
          contentType = APPLICATION_JSON
          content = CONTENT_BODY
          accept = APPLICATION_JSON
        }
        .andExpect {
          status { isInternalServerError() }
          hasStandardApiResponseFields(PATH, INTERNAL_SERVER_ERROR)
          hasErrorFields(INTERNAL_SERVER_ERROR)
        }
  }

  @Test
  fun `deleteFilm returns INTERNAL_SERVER_ERROR`() {
    val filmId = 1
    mockMvc
        .delete("$PATH/$filmId") { accept = APPLICATION_JSON }
        .andExpect {
          status { isInternalServerError() }
          hasStandardApiResponseFields("$PATH/$filmId", INTERNAL_SERVER_ERROR)
          hasErrorFields(INTERNAL_SERVER_ERROR)
        }
  }

  @Test
  fun `updateFilm returns INTERNAL_SERVER_ERROR`() {
    val filmId = 1
    mockMvc
        .put("$PATH/$filmId") {
          contentType = APPLICATION_JSON
          content = CONTENT_BODY
          accept = APPLICATION_JSON
        }
        .andExpect {
          status { isInternalServerError() }
          hasStandardApiResponseFields("$PATH/$filmId", INTERNAL_SERVER_ERROR)
          hasErrorFields(INTERNAL_SERVER_ERROR)
        }
  }
}

Groovy

groovy/dev/pollito/spring_groovy/sakila/film/adapter/in/rest/FilmRestControllerMockMvcSpec.groovy

package dev.pollito.spring_groovy.sakila.film.adapter.in.rest

import static java.time.OffsetDateTime.now
import static org.springframework.http.HttpStatus.*
import static org.springframework.http.MediaType.APPLICATION_JSON
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*

import dev.pollito.spring_groovy.config.mapper.ModelMapperConfig
import dev.pollito.spring_groovy.config.web.ControllerAdvice
import dev.pollito.spring_groovy.sakila.film.domain.model.Film
import dev.pollito.spring_groovy.sakila.film.domain.port.in.FilmUseCases
import dev.pollito.spring_groovy.test.util.MockMvcResultMatchersTrait
import org.spockframework.spring.SpringBean
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest
import org.springframework.context.annotation.Import
import org.springframework.test.web.servlet.MockMvc
import spock.lang.Specification

@WebMvcTest(FilmRestController)
@Import([ControllerAdvice, FilmRestMapper, ModelMapperConfig])
class FilmRestControllerMockMvcSpec extends Specification implements MockMvcResultMatchersTrait {

  private static final String PATH = "/api/films"
  private static final String CONTENT_BODY = """
        {
            "title": "ACADEMY DINOSAUR",
            "language": "English",
            "rentalDuration": 3,
            "rentalRate": 4.99,
            "replacementCost": 20.99
        }
    """

  @Autowired
  MockMvc mockMvc

  @SpringBean
  FilmUseCases useCases = Mock()

  def "getFilm returns OK"() {
    given: "a mocked domain model and primary port behavior"
    def id = 1
    useCases.getFilm(id) >> Stub(Film){getLastUpdate() >> now()}

    when: "getFilm is requested"
    def result = mockMvc.perform(
        get(PATH + "/{id}", id)
        .accept(APPLICATION_JSON)
        )

    then: "response is OK"
    result
        .andExpect(status().isOk())
        .andExpect(content().contentType(APPLICATION_JSON))
        .andExpect(hasStandardApiResponseFields("${PATH}/${id}", OK))
  }

  def "getFilms returns INTERNAL_SERVER_ERROR"() {
    when: "getFilms is requested"
    def result = mockMvc.perform(
        get(PATH)
        .accept(APPLICATION_JSON)
        )

    then: "response is INTERNAL_SERVER_ERROR"
    result
        .andExpect(hasStandardApiResponseFields(PATH, INTERNAL_SERVER_ERROR))
        .andExpect(hasErrorFields(INTERNAL_SERVER_ERROR))
  }

  def "createFilm returns INTERNAL_SERVER_ERROR"() {
    when: "createFilm is requested"
    def result = mockMvc.perform(
        post(PATH)
        .contentType(APPLICATION_JSON)
        .content(CONTENT_BODY)
        .accept(APPLICATION_JSON)
        )

    then: "response is INTERNAL_SERVER_ERROR"
    result
        .andExpect(hasStandardApiResponseFields(PATH, INTERNAL_SERVER_ERROR))
        .andExpect(hasErrorFields(INTERNAL_SERVER_ERROR))
  }

  def "deleteFilm returns INTERNAL_SERVER_ERROR"() {
    given: "an id"
    def id = 1

    when: "deleteFilm is requested"
    def result = mockMvc.perform(
        delete(PATH + "/{id}", id)
        .accept(APPLICATION_JSON)
        )

    then: "response is INTERNAL_SERVER_ERROR"
    result
        .andExpect(hasStandardApiResponseFields("${PATH}/${id}", INTERNAL_SERVER_ERROR))
        .andExpect(hasErrorFields(INTERNAL_SERVER_ERROR))
  }

  def "updateFilm returns INTERNAL_SERVER_ERROR"() {
    given: "an id"
    def id = 1

    when: "updateFilm is requested"
    def result = mockMvc.perform(
        put(PATH + "/{id}", id)
        .contentType(APPLICATION_JSON)
        .content(CONTENT_BODY)
        .accept(APPLICATION_JSON)
        )

    then: "response is INTERNAL_SERVER_ERROR"
    result
        .andExpect(hasStandardApiResponseFields("${PATH}/${id}", INTERNAL_SERVER_ERROR))
        .andExpect(hasErrorFields(INTERNAL_SERVER_ERROR))
  }
}

MockMvc Standalone

El objetivo de estos tests es verificar que nuestro ControllerAdvice maneja diferentes escenarios de excepciones correctamente. Testeamos que los errores de validación devuelvan códigos de estado HTTP y estructuras de respuesta apropiadas, asegurando que nuestra API proporcione respuestas de error consistentes en diferentes modos de falla.

Java

java/dev/pollito/spring_java/config/web/ControllerAdviceMockMvcTest.java

package dev.pollito.spring_java.config.web;

import static dev.pollito.spring_java.test.util.MockMvcResultMatchers.hasErrorFields;
import static dev.pollito.spring_java.test.util.MockMvcResultMatchers.hasStandardApiResponseFields;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.springframework.http.HttpMethod.GET;
import static org.springframework.http.HttpStatus.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.validation.ConstraintViolationException;
import java.util.Set;
import java.util.stream.Stream;
import org.jspecify.annotations.NonNull;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.resource.NoResourceFoundException;

class ControllerAdviceMockMvcTest {

  private MockMvc mockMvc;
  private final HttpServletRequest request = mock(HttpServletRequest.class);

  @RestController
  @RequestMapping("/fake")
  private static class FakeController {

    @GetMapping("/not-found")
    @SuppressWarnings("unused")
    public void throwNoResourceFoundException() throws NoResourceFoundException {
      throw new NoResourceFoundException(GET, "/fake", "no-resource-found");
    }

    @GetMapping("/error")
    @SuppressWarnings("unused")
    public void throwException() throws Exception {
      throw new Exception("Test exception");
    }

    @GetMapping("/bad-request")
    @SuppressWarnings("unused")
    public void throwConstraintViolationException() {
      throw new ConstraintViolationException("Constraint violation", Set.of());
    }

    @GetMapping("/method-arg-not-valid")
    @SuppressWarnings({"unused"})
    public void throwMethodArgumentNotValidException() throws Exception {
      throw new MethodArgumentNotValidException(
          new MethodParameter(
              FakeController.class.getMethod("throwMethodArgumentNotValidException"), -1),
          mock(BindingResult.class));
    }
  }

  @BeforeEach
  void setUp() {
    mockMvc =
        standaloneSetup(new FakeController())
            .setControllerAdvice(new ControllerAdvice(request))
            .build();
  }

  static @NonNull Stream<Arguments> testCases() {
    return Stream.of(
        Arguments.of("/fake/not-found", NOT_FOUND),
        Arguments.of("/fake/error", INTERNAL_SERVER_ERROR),
        Arguments.of("/fake/bad-request", BAD_REQUEST),
        Arguments.of("/fake/method-arg-not-valid", BAD_REQUEST));
  }

  @ParameterizedTest
  @MethodSource("testCases")
  void exceptionHandlingReturnsCorrectStatus(String path, @NonNull HttpStatus expectedStatus)
      throws Exception {
    when(request.getRequestURI()).thenReturn(path);
    mockMvc
        .perform(get(path))
        .andExpect(status().is(expectedStatus.value()))
        .andExpect(hasStandardApiResponseFields(path, expectedStatus))
        .andExpect(hasErrorFields(expectedStatus));
  }
}

Kotlin

kotlin/dev/pollito/spring_kotlin/config/web/ControllerAdviceMockMvcTest.kt

package dev.pollito.spring_kotlin.config.web

import dev.pollito.spring_kotlin.test.util.hasErrorFields
import dev.pollito.spring_kotlin.test.util.hasStandardApiResponseFields
import io.mockk.every
import io.mockk.mockk
import jakarta.servlet.http.HttpServletRequest
import jakarta.validation.ConstraintViolationException
import java.util.stream.Stream
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.MethodSource
import org.springframework.core.MethodParameter
import org.springframework.http.HttpMethod.GET
import org.springframework.http.HttpStatus
import org.springframework.http.HttpStatus.*
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup
import org.springframework.validation.BindingResult
import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import org.springframework.web.servlet.resource.NoResourceFoundException

class ControllerAdviceMockMvcTest {

  private lateinit var mockMvc: MockMvc
  private val request = mockk<HttpServletRequest>()

  @RestController
  @RequestMapping("/fake")
  class FakeController {

    @GetMapping("/not-found")
    fun throwNoResourceFoundException() {
      throw NoResourceFoundException(GET, "/fake/not-found", "no-resource-found")
    }

    @GetMapping("/error")
    fun throwException() {
      throw Exception("Test exception")
    }

    @GetMapping("/bad-request")
    fun throwConstraintViolationException() {
      throw ConstraintViolationException("Constraint violation", emptySet())
    }

    @GetMapping("/method-arg-not-valid")
    fun throwMethodArgumentNotValidException() {
      throw MethodArgumentNotValidException(
          MethodParameter(
              FakeController::class.java.getMethod("throwMethodArgumentNotValidException"),
              -1,
          ),
          mockk<BindingResult>(relaxed = true),
      )
    }
  }

  companion object {
    @JvmStatic
    fun testCases(): Stream<Arguments> =
        Stream.of(
            Arguments.of("/fake/not-found", NOT_FOUND),
            Arguments.of("/fake/error", INTERNAL_SERVER_ERROR),
            Arguments.of("/fake/bad-request", BAD_REQUEST),
            Arguments.of("/fake/method-arg-not-valid", BAD_REQUEST),
        )
  }

  @BeforeEach
  fun setUp() {
    mockMvc =
        standaloneSetup(FakeController()).setControllerAdvice(ControllerAdvice(request)).build()
  }

  @ParameterizedTest(name = "{1}")
  @MethodSource("testCases")
  fun `exception handling returns correct status`(expectedInstance: String, status: HttpStatus) {
    every { request.requestURI } returns expectedInstance

    mockMvc.get(expectedInstance).andExpect {
      status { isEqualTo(status.value()) }
      hasStandardApiResponseFields(expectedInstance, status)
      hasErrorFields(status)
    }
  }
}

Groovy

groovy/dev/pollito/spring_groovy/config/web/ControllerAdviceMockMvcSpec.groovy

package dev.pollito.spring_groovy.config.web

import static org.springframework.http.HttpMethod.GET
import static org.springframework.http.HttpStatus.*
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.standaloneSetup

import dev.pollito.spring_groovy.test.util.MockMvcResultMatchersTrait
import jakarta.servlet.http.HttpServletRequest
import jakarta.validation.ConstraintViolationException
import org.springframework.core.MethodParameter
import org.springframework.test.web.servlet.MockMvc
import org.springframework.validation.BeanPropertyBindingResult
import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import org.springframework.web.servlet.resource.NoResourceFoundException
import spock.lang.Specification
import spock.lang.Unroll

class ControllerAdviceMockMvcSpec extends Specification implements MockMvcResultMatchersTrait {
  MockMvc mockMvc
  HttpServletRequest request = Mock()

  @RestController
  @RequestMapping("/fake")
  static class FakeController {

    @GetMapping("/not-found")
    @SuppressWarnings("unused")
    static void throwNoResourceFoundException() throws NoResourceFoundException {
      throw new NoResourceFoundException(GET, "/fake", "no-resource-found")
    }

    @GetMapping("/error")
    @SuppressWarnings("unused")
    static void throwException() throws Exception {
      throw new Exception("Test exception")
    }

    @GetMapping("/bad-request")
    @SuppressWarnings("unused")
    static void throwConstraintViolationException() {
      throw new ConstraintViolationException("Constraint violation", Set.of())
    }

    @GetMapping("/method-argument-not-valid")
    @SuppressWarnings("unused")
    static void throwMethodArgumentNotValidException() throws MethodArgumentNotValidException {
      throw new MethodArgumentNotValidException(
      new MethodParameter(String.class.getMethod("valueOf", Object.class), 0),
      new BeanPropertyBindingResult(new Object(), "object")
      )
    }
  }

  def setup() {
    mockMvc = standaloneSetup(new FakeController())
        .setControllerAdvice(new ControllerAdvice(request))
        .build()
  }

  @Unroll
  def "#exceptionType returns #httpStatus"() {
    given:
    request.getRequestURI() >> endpoint

    expect:
    mockMvc.perform(get(endpoint))
        .andExpect(status().is(httpStatus.value()))
        .andExpect(hasStandardApiResponseFields(endpoint, httpStatus))
        .andExpect(hasErrorFields(httpStatus))

    where:
    endpoint                            | httpStatus            || exceptionType
    "/fake/not-found"                   | NOT_FOUND             || "NoResourceFoundException"
    "/fake/error"                       | INTERNAL_SERVER_ERROR || "Exception"
    "/fake/bad-request"                 | BAD_REQUEST           || "ConstraintViolationException"
    "/fake/method-argument-not-valid"   | BAD_REQUEST           || "MethodArgumentNotValidException"
  }
}

No te olvidés de actualizar la clase ControllerAdvice para manejar las excepciones testeadas.

Java

java/dev/pollito/spring_java/config/web/ControllerAdvice.java (new exception handlers)

  @ExceptionHandler(ConstraintViolationException.class)
  public ResponseEntity<Error> handle(ConstraintViolationException e) {
    return buildProblemDetail(e, BAD_REQUEST);
  }

  @ExceptionHandler(MethodArgumentNotValidException.class)
  public ResponseEntity<Error> handle(MethodArgumentNotValidException e) {
    return buildProblemDetail(e, BAD_REQUEST);
  }

Kotlin

kotlin/dev/pollito/spring_kotlin/config/web/ControllerAdvice.kt (new exception handlers)

  @ExceptionHandler(ConstraintViolationException::class)
  fun handle(e: ConstraintViolationException): ResponseEntity<Error> {
    return buildErrorResponse(e, BAD_REQUEST)
  }

  @ExceptionHandler(MethodArgumentNotValidException::class)
  fun handle(e: MethodArgumentNotValidException): ResponseEntity<Error> {
    return buildErrorResponse(e, BAD_REQUEST)
  }

Groovy

groovy/dev/pollito/spring_groovy/config/web/ControllerAdvice.groovy (new exception handlers)

  @ExceptionHandler(ConstraintViolationException)
  ResponseEntity<Error> handle(ConstraintViolationException e) {
    buildErrorResponse(e, BAD_REQUEST)
  }

  @ExceptionHandler(MethodArgumentNotValidException)
  ResponseEntity<Error> handle(MethodArgumentNotValidException e) {
    buildErrorResponse(e, BAD_REQUEST)
  }

Ver el reporte de JaCoCo

Java

Package / Class	Coverage		Complexity		Lines		Methods		Classes
	Instr. %	Branch %	Missed	Total	Missed	Total	Missed	Total	Missed	Total
dev.pollito.spring_java.common.util	100%	100%	0	3	0	4	0	1	0	1
dev.pollito.spring_java.config.web	93%	66%	1	8	1	19	0	6	0	1
dev.pollito.spring_java.sakila.film.adapter.in.rest	100%	n/a	0	5	0	10	0	5	0	1
dev.pollito.spring_java.sakila.film.domain.service	100%	n/a	0	2	0	16	0	2	0	1
Total	97%	85%	1	18	1	49	0	14	0	4

Kotlin

Package / Class	Coverage		Complexity		Lines		Methods		Classes
	Instr. %	Branch %	Missed	Total	Missed	Total	Missed	Total	Missed	Total
dev.pollito.spring_kotlin.common.util	100%	100%	0	2	0	2	0	1	0	1
dev.pollito.spring_kotlin.config.web	92%	75%	3	13	1	22	2	11	0	2
dev.pollito.spring_kotlin.sakila.film.adapter.in.rest	100%	n/a	0	6	0	16	0	6	0	1
dev.pollito.spring_kotlin.sakila.film.domain.service	100%	n/a	0	2	0	15	0	2	0	1
Total	96%	83%	3	23	1	55	2	20	0	5

Groovy

Package / Class	Coverage		Complexity		Lines		Methods		Classes
	Instr. %	Branch %	Missed	Total	Missed	Total	Missed	Total	Missed	Total
dev.pollito.spring_groovy.common.util	87%	100%	1	3	1	5	1	2	0	1
dev.pollito.spring_groovy.config.web	92%	75%	1	9	2	26	0	7	0	1
dev.pollito.spring_groovy.sakila.film.adapter.in.rest	100%	n/a	0	8	0	19	0	8	0	2
dev.pollito.spring_groovy.sakila.film.domain.service	100%	n/a	0	2	0	14	0	2	0	1
Total	95%	83%	2	22	3	64	1	19	0	5

JaCoCo Limitations with Groovy Spring Boot Projects

JaCoCo funciona a nivel de bytecode, pero Groovy genera bytecode significativamente diferente al que escribís en código fuente. Para proyectos Groovy (especialmente con Spring Boot), deberías generalmente ignorar las columnas "Instructions" y "Branches" y enfocarte casi exclusivamente en Line Coverage.

Acá está lo que significa cada columna en un reporte de cobertura de JaCoCo:

Columna	Significado	Notas / Cuándo Importar
Name	El package, clase, archivo, o método siendo medido	La fila Total agrega todas las entradas
Instruction Coverage	Porcentaje de instrucciones de bytecode JVM ejecutadas	Muy detallado; puede ser engañoso para Groovy
Branch Coverage	Porcentaje de branches condicionales ejecutados (if, switch, loops)	Genial para atrapar caminos de lógica no testeados
Missed Complexity	Complejidad ciclomática no cubierta por tests	Indica flujo de control riesgoso o no testeado
Total Complexity	Complejidad ciclomática total del código	Valores más altos significan lógica más compleja
Missed Lines	Número de líneas ejecutables de código no corrida	Basado en líneas con bytecode
Total Lines	Total de líneas ejecutables de código	Métrica de coverage más intuitiva
Missed Methods	Métodos nunca invocados por tests	Bueno para detectar APIs no testeadas
Total Methods	Número total de métodos	Incluye constructores y lambdas
Missed Classes	Clases nunca cargadas durante tests	Indicador de completitud de tests de alto nivel
Total Classes	Número total de clases	Incluye clases internas y anónimas

Ahora tenemos tests unitarios para lógica de dominio y utilidades enum, tests de segmento para la capa web, y seguimiento de cobertura con JaCoCo en cada build.