Upgrade to Spring Boot 4.0

Author: bclozel

README.adoc

@@ -5,37 +5,34 @@
 :source-highlighter: prettify
 :project_id: gs-testing-web
 
-This guide walks you through the process of creating a Spring application and then testing
-it with JUnit.
+This guide walks you through the process of creating a Spring application and then testing it with JUnit.
 
 == What You Will Build
 
-You will build a simple Spring application and test it with JUnit. You probably already
-know how to write and run unit tests of the individual classes in your application, so,
-for this guide, we will concentrate on using Spring Test and Spring Boot features to test
-the interactions between Spring and your code. You will start with a simple test that the
-application context loads successfully and continue on to test only the web layer by using
-Spring's `MockMvc`.
+You will build a simple Spring application and test it with JUnit.
+You probably already know how to write and run unit tests of the individual classes in your application, so,
+for this guide, we will concentrate on using Spring Test and Spring Boot features to test the interactions between Spring and your code.
+You will start with a simple test that the application context loads successfully and continue on to test only the web layer by using Spring's `MockMvc`.
 
 
 == What You Need
 
-:java_version: 1.8
+:java_version: 17
 include::https://raw.githubusercontent.com/spring-guides/getting-started-macros/main/prereq_editor_jdk_buildtools.adoc[]
 
 include::https://raw.githubusercontent.com/spring-guides/getting-started-macros/main/how_to_complete_this_guide.adoc[]
 
 [[scratch]]
 == Starting with Spring Initializr
 
-You can use this https://start.spring.io/#!type=maven-project&packaging=jar&jvmVersion=17&groupId=com.example&artifactId=testing-web&name=testing-web&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.testingweb&dependencies=web[pre-initialized project] and click Generate to download a ZIP file. This project is configured to fit the examples in this tutorial.
+You can use this https://start.spring.io/#!type=gradle-project&packaging=jar&jvmVersion=17&groupId=com.example&artifactId=testing-web&name=testing-web&packageName=com.example.testingweb&dependencies=web,spring-restclient[pre-initialized project] and click Generate to download a ZIP file. This project is configured to fit the examples in this tutorial.
 
 To manually initialize the project:
 
 . Navigate to https://start.spring.io.
 This service pulls in all the dependencies you need for an application and does most of the setup for you.
 . Choose either Gradle or Maven and the language you want to use.
-. Click *Dependencies* and select *Spring Web*.
+. Click *Dependencies* and select *Spring Web* and *HTTP Client*.
 . Click *Generate*.
 . Download the resulting ZIP file, which is an archive of a web application that is configured with your choices.
 
@@ -77,33 +74,17 @@ include::complete/src/main/java/com/example/testingweb/TestingWebApplication.jav
 include::complete-kotlin/src/main/kotlin/com/example/testingweb/TestingWebApplication.kt[]
 ----
 
-`@SpringBootApplication` is a convenience annotation that adds all of the following:
-
-- `@Configuration`: Tags the class as a source of bean definitions for the application
-context.
-- `@EnableAutoConfiguration`: Tells Spring Boot to start adding beans based on classpath
-settings, other beans, and various property settings.
-- `@EnableWebMvc`: Flags the application as a web application and activates key behaviors,
-such as setting up a `DispatcherServlet`. Spring Boot adds it  automatically when it sees
-`spring-webmvc` on the classpath.
-- `@ComponentScan`: Tells Spring to look for other components, configurations, and
-services in the package where your annotated `TestingWebApplication` class resides
-(`com.example.testingweb`), letting it find the `com.example.testingweb.HelloController`.
-
-The `main()` method uses Spring Boot's `SpringApplication.run()` method to launch an
-application. Did you notice that there is not a single line of XML? There is no `web.xml`
-file, either. You do not have to deal with configuring any plumbing or infrastructure.
-Spring Boot handles all of that for you.
-
-Logging output is displayed. The service should be up and running within a few seconds.
-
-== Test the Application
+You can run this application class from your IDE directly, or from the command line using
+Gradle (`./gradlew :bootRun`) or Maven (`./mvwn spring-boot:run`).
 
 Now that the application is running, you can test it. You can load the home page at
 `http://localhost:8080`. However, to give yourself more confidence that the application
 works when you make changes, you want to automate the testing.
 
-NOTE: Spring Boot assumes you plan to test your application, so it adds the necessary
+
+== Test the Application
+
+Spring Boot assumes you plan to test your application, so it adds the necessary
 dependencies to your build file (`build.gradle` or `pom.xml`).
 
 The first thing you can do is write a simple sanity check test that will fail if the
@@ -123,7 +104,7 @@ include::initial-kotlin/src/test/kotlin/com/example/testingweb/TestingWebApplica
 The `@SpringBootTest` annotation tells Spring Boot to look for a main configuration class
 (one with `@SpringBootApplication`, for instance) and use that to start a Spring
 application context. You can run this test in your IDE or on the command line (by running
-`./mvnw test` or `./gradlew test`), and it should pass. To convince yourself that the
+`./mvnw test` or `./gradlew check`), and it should pass. To convince yourself that the
 context is creating your controller, you could add an assertion, as the following example shows:
 
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
@@ -141,12 +122,6 @@ Spring interprets the `@Autowired` annotation, and the controller is injected be
 test methods are run. We use https://assertj.github.io/doc/[AssertJ]
 (which provides `assertThat()` and other methods) to express the test assertions.
 
-NOTE: A nice feature of the Spring Test support is that the application context is cached
-between tests. That way, if you have multiple methods in a test case or multiple test
-cases with the same configuration, they incur the cost of starting the application only
-once. You can control the cache by using the {DirtiesContext}[`@DirtiesContext`]
-annotation.
-
 It is nice to have a sanity check, but you should also write some tests that assert the
 behavior of your application. To do that, you could start the application and listen for a
 connection (as it would do in production) and then send an HTTP request and assert the
@@ -166,14 +141,16 @@ include::complete-kotlin/src/test/kotlin/com/example/testingweb/HttpRequestTest.
 Note the use of `webEnvironment=RANDOM_PORT` to start the server with a random port
 (useful to avoid conflicts in test environments) and the injection of the port with
 `@LocalServerPort`. Also, note that Spring Boot has automatically provided a
-`TestRestTemplate` for you. All you have to do is add `@Autowired` to it.
+`RestTestClient` for you because we expressed the need for it with `@AutoConfigureRestTestClient`.
+All you have to do after that is to add `@Autowired` to the field.
 
 Another useful approach is to not start the server at all but to test only the layer below
 that, where Spring handles the incoming HTTP request and hands it off to your controller.
 That way, almost all of the full stack is used, and your code will be called in exactly the
 same way as if it were processing a real HTTP request but without the cost of starting the
-server. To do that, use Spring's `MockMvc` and ask for that to be injected for you by
-using the `@AutoConfigureMockMvc` annotation on the test case. The following listing shows how to do so:
+server. To do that, we can reuse our previous test using `RestTestClient`, but this time
+leaving `@SpringBootTest` with its default, which is to start a mock server environment.
+The following listing shows how to do so:
 
 [source,java,indent=0,subs="verbatim,quotes",role="primary"]
 .Java

complete-kotlin/build.gradle.kts

@@ -1,27 +1,39 @@
 plugins {
-    id("org.springframework.boot") version "3.5.7"
+    kotlin("jvm") version "2.2.21"
+    kotlin("plugin.spring") version "2.2.21"
+    id("org.springframework.boot") version "4.0.0"
     id("io.spring.dependency-management") version "1.1.7"
-    kotlin("jvm") version "1.9.25"
-    kotlin("plugin.spring") version "1.9.25"
 }
 
 group = "com.example"
 version = "0.0.1-SNAPSHOT"
-java.sourceCompatibility = JavaVersion.VERSION_17
+description = "Demo project for Spring Boot"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
 
 repositories {
     mavenCentral()
 }
 
 dependencies {
-    implementation("org.springframework.boot:spring-boot-starter-web")
-    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
+    implementation("org.springframework.boot:spring-boot-starter-restclient")
+    implementation("org.springframework.boot:spring-boot-starter-webmvc")
     implementation("org.jetbrains.kotlin:kotlin-reflect")
-    testImplementation("org.springframework.boot:spring-boot-starter-test")
+    implementation("tools.jackson.module:jackson-module-kotlin")
+    testImplementation("org.springframework.boot:spring-boot-starter-restclient-test")
+    testImplementation("org.springframework.boot:spring-boot-starter-webmvc-test")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit5")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 kotlin {
-    jvmToolchain(17)
+    compilerOptions {
+        freeCompilerArgs.addAll("-Xjsr305=strict", "-Xannotation-default-target=param-property")
+    }
 }
 
 tasks.withType<Test> {

complete-kotlin/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

complete-kotlin/src/main/resources/application.properties

@@ -0,0 +1 @@
+spring.application.name=testing-web

complete-kotlin/src/test/kotlin/com/example/testingweb/HttpRequestTest.kt

@@ -1,27 +1,32 @@
 package com.example.testingweb
 
-import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient
 import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.boot.test.web.client.TestRestTemplate
 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
-import org.springframework.boot.test.web.client.getForObject
 import org.springframework.boot.test.web.server.LocalServerPort
+import org.springframework.test.web.servlet.client.RestTestClient
+import org.springframework.test.web.servlet.client.expectBody
 
 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@AutoConfigureRestTestClient
 class HttpRequestTest {
 
     @LocalServerPort
     private var port: Int = 0
 
     @Autowired
-    private lateinit var restTemplate: TestRestTemplate
+    private lateinit var restTestClient: RestTestClient
 
     @Test
     fun greetingShouldReturnDefaultMessage() {
-        // Import Kotlin .getForObject() extension that allows using reified type parameters
-        assertThat(this.restTemplate.getForObject<String>("http://localhost:$port/"))
-            .contains("Hello, World")
+        // Import Kotlin .expectBody() extension that allows using reified type parameters
+        restTestClient.get()
+            .uri("http://localhost:$port/")
+            .exchange()
+            .expectBody<String>()
+            .isEqualTo("Hello, World")
     }
-}
+
+}

complete-kotlin/src/test/kotlin/com/example/testingweb/TestingWebApplicationTest.kt

@@ -1,28 +1,26 @@
 package com.example.testingweb
 
-import org.hamcrest.Matchers.containsString
 import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
+import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient
 import org.springframework.boot.test.context.SpringBootTest
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.result.MockMvcResultHandlers.print
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.content
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.springframework.test.web.servlet.client.RestTestClient
+import org.springframework.test.web.servlet.client.expectBody
 
 @SpringBootTest
-@AutoConfigureMockMvc
+@AutoConfigureRestTestClient
 class TestingWebApplicationTest {
 
     @Autowired
-    private lateinit var mockMvc: MockMvc
+    private lateinit var restTestClient: RestTestClient
 
     @Test
-    fun shouldReturnDefaultMessage() {
-        mockMvc.perform(get("/"))
-            .andDo(print())
-            .andExpect(status().isOk())
-            .andExpect(content().string(containsString("Hello, World")))
+    fun greetingShouldReturnDefaultMessage() {
+        // Import Kotlin .expectBody() extension that allows using reified type parameters
+        restTestClient.get().uri("/")
+            .exchange()
+            .expectBody<String>()
+            .isEqualTo("Hello, World")
     }
+
 }

complete-kotlin/src/test/kotlin/com/example/testingweb/WebLayerTest.kt

@@ -1,26 +1,27 @@
 package com.example.testingweb
 
-import org.hamcrest.Matchers.containsString
 import org.junit.jupiter.api.Test
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.result.MockMvcResultHandlers.print
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.content
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient
+import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest
+import org.springframework.test.web.servlet.client.RestTestClient
+import org.springframework.test.web.servlet.client.expectBody
 
 @WebMvcTest(HomeController::class)
+@AutoConfigureRestTestClient
 class WebLayerTest {
 
     @Autowired
-    private lateinit var mockMvc: MockMvc
+    private lateinit var restTestClient: RestTestClient
 
     @Test
-    fun shouldReturnDefaultMessage() {
-        mockMvc.perform(get("/"))
-            .andDo(print())
-            .andExpect(status().isOk())
-            .andExpect(content().string(containsString("Hello, World")))
+    fun greetingShouldReturnDefaultMessage() {
+        // Import Kotlin .expectBody() extension that allows using reified type parameters
+        restTestClient.get()
+            .uri("/")
+            .exchange()
+            .expectBody<String>()
+            .isEqualTo("Hello, World")
     }
+
 }

complete-kotlin/src/test/kotlin/com/example/testingweb/WebMockTest.kt

@@ -1,32 +1,32 @@
 package com.example.testingweb
 
-import org.hamcrest.Matchers.containsString
 import org.junit.jupiter.api.Test
 import org.mockito.Mockito.`when`
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
+import org.springframework.boot.resttestclient.autoconfigure.AutoConfigureRestTestClient
+import org.springframework.boot.webmvc.test.autoconfigure.WebMvcTest
 import org.springframework.test.context.bean.override.mockito.MockitoBean
-import org.springframework.test.web.servlet.MockMvc
-import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import org.springframework.test.web.servlet.result.MockMvcResultHandlers.print
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.content
-import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import org.springframework.test.web.servlet.client.RestTestClient
+import org.springframework.test.web.servlet.client.expectBody
 
 @WebMvcTest(GreetingController::class)
+@AutoConfigureRestTestClient
 class WebMockTest {
 
     @Autowired
-    private lateinit var mockMvc: MockMvc
+    private lateinit var restTestClient: RestTestClient
 
     @MockitoBean
     private lateinit var service: GreetingService
 
     @Test
     fun greetingShouldReturnMessageFromService() {
         `when`(service.greet()).thenReturn("Hello, Mock")
-        mockMvc.perform(get("/greeting"))
-            .andDo(print())
-            .andExpect(status().isOk())
-            .andExpect(content().string(containsString("Hello, Mock")))
+        // Import Kotlin .expectBody() extension that allows using reified type parameters
+        restTestClient.get()
+            .uri("/greeting")
+            .exchange()
+            .expectBody<String>()
+            .isEqualTo("Hello, Mock")
     }
 }

complete/build.gradle

@@ -1,22 +1,30 @@
 plugins {
-	id 'org.springframework.boot' version '3.5.7'
-	id 'io.spring.dependency-management' version '1.1.7'
 	id 'java'
+	id 'org.springframework.boot' version '4.0.0'
+	id 'io.spring.dependency-management' version '1.1.7'
 }
 
 group = 'com.example'
 version = '0.0.1-SNAPSHOT'
-sourceCompatibility = '17'
+description = 'Demo project for Spring Boot'
+
+java {
+	toolchain {
+		languageVersion = JavaLanguageVersion.of(17)
+	}
+}
 
 repositories {
 	mavenCentral()
 }
 
 dependencies {
-	implementation 'org.springframework.boot:spring-boot-starter-web'
-	testImplementation('org.springframework.boot:spring-boot-starter-test')
+	implementation 'org.springframework.boot:spring-boot-starter-restclient'
+	implementation 'org.springframework.boot:spring-boot-starter-webmvc'
+	testImplementation 'org.springframework.boot:spring-boot-starter-restclient-test'
+	testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
 }
 
-test {
+tasks.named('test') {
 	useJUnitPlatform()
 }