First tests

Complete Code

The end result of the code developed in this document can be found in the GitHub monorepo springboot-demo-projects, commit(s) Testing Java, Testing Kotlin, Testing Groovy

In the previous document we compared JVM testing frameworks and picked one for each language. Now we put those frameworks to work: write unit tests, slice tests, and check the results with JaCoCo.

Files to Create/Modify

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

Testing strategy

Pick a framework

• For the Java Spring Boot App we are going to choose JUnit + Mockito: is the de-facto standard, the one always being asked in interviews, and the one you are expected to know.
• For the Kotlin Spring Boot App we are going to choose JUnit + MockK: kotlin native tools + kotlin-first mocking.
• For the Groovy Spring Boot Project we are going to choose Spock, as is the natural less friction choice.

JaCoCo

JaCoCo (Java Code Coverage) tells you which lines of code your tests execute. It is the standard coverage tool for JVM projects.

When running the test or jacocoTestReport task, JaCoCo will generate reports in HTML (for humans) and XML (for CI tools) at build/reports/jacoco/test.

What files to test

Should I create one test per every main package file? Can I group tests? Which kind of test is better? All these questions don't have one truth answer. It changes from team to team, and from developer to developer. Here I share my approach, feel free to follow it, adapt it, change it as much as needed.

Given a REST + Database CRUD project following hexagonal architecture:

• Adapter In related classes that adapt REST can be grouped and tested together under a @WebMvcTest Web layer slice test.
• Adapter Out related classes that adapt JPA can be grouped and tested together under a @DataJpaTest JPA layer slice test.
• Domain Use cases Implementations can be grouped and tested together under a unit test.
• Configuration classes are tricky. Most teams just ignore them completely. My take on them are:
  • Web @RestControllerAdvice classes are tested with a MockMvc Standalone @WebMvcTest Web layer slice test.
  • I've seen developers test log related classes in integration tests. My take is to just avoid testing log related filters and aspects. Too much trouble for too little win.

◀─────────────────────── TEST SPECTRUM ───────────────────────▶

UNIT                                                INTEGRATION
FAST                                                      SLOW
ISOLATED                                              CONNECTED

⚪──────────⚪──────────⚪──────────⚪
 │           │           │           │
 │           │           │           └── Full Spring Boot
 │           │           └── Web Layer Only
 │           └── MockMvc Standalone
 └── Pure Unit Test

Dependencies

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
}

Unit tests

Unit tests don't involve Spring at all. These are faster to run and perfect for testing business logic in complete isolation.

Keep It Real

The tests shown here are intentionally simple. They demonstrate wiring and basic assertions, not exhaustive validation. How deep you go with testing is ultimately a team (and developer) philosophy. It is very easy to write trivial tests that paint every line green in a JaCoCo report without actually testing anything meaningful. Treat coverage as a guide, not a goal.

Use cases implementation test

FilmUseCasesImpl.getFilm() is currently just returning a hardcoded film. There's not much point in doing deep testing here yet, but let's at least verify the service instantiates and returns something.

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
  }
}

Valued enum utility test

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

Web layer

We're testing three things here:

• REST endpoint behavior: Does the controller map requests correctly and return the expected responses?
• Exception handling: When things go wrong, does our error response structure look right?
• JSON response structure: Does the final JSON match our API contract?

To make our assertions more readable, we'll first create some custom matchers for our API response structure:

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

By extending MockMvcResultMatchersDsl, our custom matchers integrate seamlessly with Spring's Kotlin DSL. They can be called directly inside the andExpect block, making the test code read like a native part of the 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

A trait is like an interface with implementation that can be mixed into classes. By implementing this trait in your Spock specifications, the matcher methods become available as if they were defined directly in your test class, no static imports needed. Unlike abstract base classes, you can implement multiple traits, keeping your test hierarchy flexible.

Now let's write the actual RestController test using a slice testing approach with @WebMvcTest, which creates a minimal Spring context focused on the web layer.

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

The goal of these tests is to verify ControllerAdvice handles different exception scenarios correctly. We test that validation errors return appropriate HTTP status codes and response structures, ensuring our API provides consistent error responses across different failure modes.

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"
  }
}

Don't forget to update ControllerAdvice to handle the exceptions tested.

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)
  }

Check the JaCoCo report

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 works at the bytecode level, but Groovy generates significantly different bytecode than what you write in source code. For Groovy projects (especially with Spring Boot), you should generally ignore the "Instructions" and "Branches" columns and focus almost exclusively on Line Coverage.

Here's what each column in a JaCoCo coverage report means:

Column	Meaning	Notes / When to Care
Name	The package, class, file, or method being measured	The Total row aggregates all entries
Instruction Coverage	Percentage of JVM bytecode instructions executed	Very fine‑grained; can be misleading for Groovy
Branch Coverage	Percentage of conditional branches executed (if, switch, loops)	Great for catching untested logic paths
Missed Complexity	Cyclomatic complexity not covered by tests	Indicates risky or untested control flow
Total Complexity	Total cyclomatic complexity of the code	Higher values mean more complex logic
Missed Lines	Number of executable source lines not run	Based on lines with bytecode
Total Lines	Total executable source lines	Most intuitive coverage metric
Missed Methods	Methods never invoked by tests	Good for spotting untested APIs
Total Methods	Total number of methods	Includes constructors and lambdas
Missed Classes	Classes never loaded during tests	High‑level test completeness indicator
Total Classes	Total number of classes	Includes inner/anonymous classes

We now have unit tests for domain logic and enum utilities, slice tests for the web layer, and JaCoCo tracking coverage on every build.