测试 Spring Boot 应用
Spring Boot 应用是一个 Spring ApplicationContext，因此除了通常对普通 Spring 上下文进行的操作之外，无需进行任何特殊处理即可对其进行测试。
外部属性、日志记录和 Spring Boot 的其他特性默认只有在使用 SpringApplication 创建上下文时才会被安装。 |
Spring Boot 提供了 @SpringBootTest 注解，当你需要 Spring Boot 特性时，它可以作为标准的 spring-test @ContextConfiguration 注解的替代品。该注解通过 SpringApplication 创建测试中使用的 ApplicationContext 来工作。除了 @SpringBootTest 之外，还提供了许多其他注解用于测试应用中更具体的“切片”。
如果你使用的是 JUnit 4，不要忘记也在你的测试中添加 @RunWith(SpringRunner.class) 注解，否则这些注解将被忽略。如果你使用的是 JUnit 5，则无需添加等效的 @ExtendWith(SpringExtension.class)，因为 @SpringBootTest 和其他 @…Test 注解已经使用它进行了注解。 |
默认情况下，@SpringBootTest 不会启动服务器。你可以使用 @SpringBootTest 的 webEnvironment 属性来进一步细化测试的运行方式
-
MOCK（默认值）：加载一个 webApplicationContext并提供一个模拟的 web 环境。使用此注解时不会启动嵌入式服务器。如果你的 classpath 中没有可用的 web 环境，此模式会透明地回退到创建一个常规的非 webApplicationContext。它可以与@AutoConfigureMockMvc或@AutoConfigureWebTestClient结合使用，用于对你的 web 应用进行基于模拟的测试。 -
RANDOM_PORT：加载一个WebServerApplicationContext并提供一个真实的 web 环境。嵌入式服务器会启动并监听随机端口。 -
DEFINED_PORT：加载一个WebServerApplicationContext并提供一个真实的 web 环境。嵌入式服务器会启动并监听指定的端口（来自你的application.properties）或默认端口8080。 -
NONE：使用SpringApplication加载一个ApplicationContext，但不提供*任何* web 环境（模拟的或其他）。
如果你的测试带有 @Transactional 注解，默认情况下它会在每个测试方法结束时回滚事务。然而，由于在 RANDOM_PORT 或 DEFINED_PORT 模式下使用此配置会隐式提供一个真实的 Servlet 环境，HTTP 客户端和服务器会在不同的线程中运行，因此在不同的事务中运行。在这种情况下，在服务器上启动的任何事务都不会回滚。 |
如果你的应用为管理服务器使用了不同的端口，则使用 webEnvironment = WebEnvironment.RANDOM_PORT 的 @SpringBootTest 也会在另一个随机端口上启动管理服务器。 |
检测 Web 应用类型
如果存在 Spring MVC，则会配置一个常规的基于 MVC 的应用上下文。如果你只有 Spring WebFlux，我们将检测到这一点并配置一个基于 WebFlux 的应用上下文。
如果两者都存在，Spring MVC 优先。在这种情况下，如果你想测试响应式 web 应用，你必须设置 spring.main.web-application-type 属性
-
Java
-
Kotlin
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(properties = "spring.main.web-application-type=reactive")
class MyWebFluxTests {
// ...
}import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest(properties = ["spring.main.web-application-type=reactive"])
class MyWebFluxTests {
// ...
}检测测试配置
如果你熟悉 Spring Test Framework，你可能习惯于使用 @ContextConfiguration(classes=…) 来指定要加载哪个 Spring @Configuration。或者，你可能经常在测试中使用嵌套的 @Configuration 类。
测试 Spring Boot 应用时，通常不需要这样做。每当你没有显式定义主要配置时，Spring Boot 的 @*Test 注解会自动搜索它。
搜索算法从包含测试的包向上查找，直到找到带有 @SpringBootApplication 或 @SpringBootConfiguration 注解的类。只要你以合理的方式构建了代码，通常就能找到你的主配置。
|
如果你使用测试注解来测试应用中更具体的“切片”，则应避免在主方法的应用类上添加特定于某个区域的配置设置。
|
如果你想自定义主配置，可以使用嵌套的 @TestConfiguration 类。与用于替代你的应用主配置的嵌套 @Configuration 类不同，嵌套的 @TestConfiguration 类是在你的应用主配置之外使用的。
| Spring 的测试框架会在测试之间缓存应用上下文。因此，只要你的测试共享相同的配置（无论如何发现），加载上下文这个潜在耗时的过程只发生一次。 |
使用测试配置的主方法
通常，@SpringBootTest 发现的测试配置将是你的主 @SpringBootApplication。在大多数结构良好的应用中，这个配置类也将包含用于启动应用的 main 方法。
例如，下面是一个典型 Spring Boot 应用中非常常见的代码模式
-
Java
-
Kotlin
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.docs.using.structuringyourcode.locatingthemainclass.MyApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args)
}在上面的例子中，main 方法除了委托给 SpringApplication.run(Class, String…) 外不做任何事情。但是，也可以有一个更复杂的 main 方法，在调用 SpringApplication.run(Class, String…) 之前应用自定义配置。
例如，这是一个改变 banner 模式并设置额外 profiles 的应用
-
Java
-
Kotlin
import org.springframework.boot.Banner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication application = new SpringApplication(MyApplication.class);
application.setBannerMode(Banner.Mode.OFF);
application.setAdditionalProfiles("myprofile");
application.run(args);
}
}import org.springframework.boot.Banner
import org.springframework.boot.runApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
@SpringBootApplication
class MyApplication
fun main(args: Array<String>) {
runApplication<MyApplication>(*args) {
setBannerMode(Banner.Mode.OFF)
setAdditionalProfiles("myprofile")
}
}由于 main 方法中的自定义配置会影响最终的 ApplicationContext，你可能也想使用 main 方法来创建测试中使用的 ApplicationContext。默认情况下，@SpringBootTest 不会调用你的 main 方法，而是直接使用类本身来创建 ApplicationContext
如果你想改变这种行为，可以将 @SpringBootTest 的 useMainMethod 属性更改为 SpringBootTest.UseMainMethod.ALWAYS 或 SpringBootTest.UseMainMethod.WHEN_AVAILABLE。当设置为 ALWAYS 时，如果找不到 main 方法，测试将失败。当设置为 WHEN_AVAILABLE 时，如果 main 方法可用，则会使用它，否则将使用标准的加载机制。
例如，以下测试将调用 MyApplication 的 main 方法来创建 ApplicationContext。如果 main 方法设置了额外的 profiles，那么当 ApplicationContext 启动时，这些 profiles 将会激活。
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.UseMainMethod;
@SpringBootTest(useMainMethod = UseMainMethod.ALWAYS)
class MyApplicationTests {
@Test
void exampleTest() {
// ...
}
}import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.UseMainMethod
@SpringBootTest(useMainMethod = UseMainMethod.ALWAYS)
class MyApplicationTests {
@Test
fun exampleTest() {
// ...
}
}排除测试配置
如果你的应用使用组件扫描（例如，如果你使用了 @SpringBootApplication 或 @ComponentScan），你可能会发现你仅为特定测试创建的顶级配置类意外地在所有地方都被扫描到。
如我们前面所见，可以在测试的内部类上使用 @TestConfiguration 来自定义主配置。@TestConfiguration 也可以用于顶级类。这样做表明该类不应被扫描到。然后你可以在需要的地方显式导入该类，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
@SpringBootTest
@Import(MyTestsConfiguration.class)
class MyTests {
@Test
void exampleTest() {
// ...
}
}import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.context.annotation.Import
@SpringBootTest
@Import(MyTestsConfiguration::class)
class MyTests {
@Test
fun exampleTest() {
// ...
}
}如果你直接使用 @ComponentScan（即不通过 @SpringBootApplication），你需要将 TypeExcludeFilter 注册到其中。详情请参见 TypeExcludeFilter API 文档。 |
导入的 @TestConfiguration 比内部类 @TestConfiguration 处理得更早，并且导入的 @TestConfiguration 会在通过组件扫描找到的任何配置之前处理。一般来说，这种顺序差异没有明显的影响，但如果你依赖于 bean 覆盖，则需要注意这一点。 |
使用应用参数
如果你的应用需要参数，你可以让 @SpringBootTest 使用 args 属性注入它们。
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.test.context.SpringBootTest;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(args = "--app.test=one")
class MyApplicationArgumentTests {
@Test
void applicationArgumentsPopulated(@Autowired ApplicationArguments args) {
assertThat(args.getOptionNames()).containsOnly("app.test");
assertThat(args.getOptionValues("app.test")).containsOnly("one");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.ApplicationArguments
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest(args = ["--app.test=one"])
class MyApplicationArgumentTests {
@Test
fun applicationArgumentsPopulated(@Autowired args: ApplicationArguments) {
assertThat(args.optionNames).containsOnly("app.test")
assertThat(args.getOptionValues("app.test")).containsOnly("one")
}
}在模拟环境中测试
默认情况下，@SpringBootTest 不会启动服务器，而是设置一个模拟环境来测试 web 端点。
使用 Spring MVC，我们可以使用 MockMvc 查询我们的 web 端点。有三种集成方式可用
-
使用 Hamcrest 的常规
MockMvc。 -
包装了
MockMvc并使用 AssertJ 的MockMvcTester。 -
其中
MockMvc作为服务器插入以处理请求的WebTestClient。
以下示例展示了可用的集成方式
-
Java
-
Kotlin
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.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@SpringBootTest
@AutoConfigureMockMvc
class MyMockMvcTests {
@Test
void testWithMockMvc(@Autowired MockMvc mvc) throws Exception {
mvc.perform(get("/")).andExpect(status().isOk()).andExpect(content().string("Hello World"));
}
// If AssertJ is on the classpath, you can use MockMvcTester
@Test
void testWithMockMvcTester(@Autowired MockMvcTester mvc) {
assertThat(mvc.get().uri("/")).hasStatusOk().hasBodyTextEqualTo("Hello World");
}
// If Spring WebFlux is on the classpath, you can drive MVC tests with a WebTestClient
@Test
void testWithWebTestClient(@Autowired WebTestClient webClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk()
.expectBody(String.class).isEqualTo("Hello World");
}
}import org.assertj.core.api.Assertions.assertThat
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.test.context.SpringBootTest
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
import org.springframework.test.web.servlet.assertj.MockMvcTester
@SpringBootTest
@AutoConfigureMockMvc
class MyMockMvcTests {
@Test
fun testWithMockMvc(@Autowired mvc: MockMvcTester) {
assertThat(mvc.get().uri("/")).hasStatusOk()
.hasBodyTextEqualTo("Hello World")
}
// If Spring WebFlux is on the classpath, you can drive MVC tests with a WebTestClient
@Test
fun testWithWebTestClient(@Autowired webClient: WebTestClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk
.expectBody<String>().isEqualTo("Hello World")
}
}如果你想只关注 web 层而不启动完整的 ApplicationContext，可以考虑使用 @WebMvcTest。 |
使用 Spring WebFlux 端点，你可以使用 WebTestClient，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.reactive.server.WebTestClient;
@SpringBootTest
@AutoConfigureWebTestClient
class MyMockWebTestClientTests {
@Test
void exampleTest(@Autowired WebTestClient webClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk()
.expectBody(String.class).isEqualTo("Hello World");
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.reactive.AutoConfigureWebTestClient
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
@SpringBootTest
@AutoConfigureWebTestClient
class MyMockWebTestClientTests {
@Test
fun exampleTest(@Autowired webClient: WebTestClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk
.expectBody<String>().isEqualTo("Hello World")
}
}在运行的服务器中测试
如果你需要启动一个完全运行的服务器，我们建议你使用随机端口。如果你使用 @SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)，每次测试运行时都会随机选择一个可用端口。
可以使用 @LocalServerPort 注解将实际使用的端口注入到你的测试中。为了方便起见，需要向已启动服务器进行 REST 调用的测试还可以自动注入一个 WebTestClient，它可以将相对链接解析到正在运行的服务器，并提供一个专门用于验证响应的 API，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.test.web.reactive.server.WebTestClient;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyRandomPortWebTestClientTests {
@Test
void exampleTest(@Autowired WebTestClient webClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk()
.expectBody(String.class).isEqualTo("Hello World");
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyRandomPortWebTestClientTests {
@Test
fun exampleTest(@Autowired webClient: WebTestClient) {
webClient
.get().uri("/")
.exchange()
.expectStatus().isOk
.expectBody<String>().isEqualTo("Hello World")
}
}
WebTestClient 也可以与模拟环境一起使用，通过使用 @AutoConfigureWebTestClient 注解测试类来消除对运行服务器的需求。 |
此设置需要在 classpath 中包含 spring-webflux。如果你不能或不想添加 webflux，Spring Boot 还提供了 TestRestTemplate 工具
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyRandomPortTestRestTemplateTests {
@Test
void exampleTest(@Autowired TestRestTemplate restTemplate) {
String body = restTemplate.getForObject("/", String.class);
assertThat(body).isEqualTo("Hello World");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.boot.test.web.client.TestRestTemplate
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyRandomPortTestRestTemplateTests {
@Test
fun exampleTest(@Autowired restTemplate: TestRestTemplate) {
val body = restTemplate.getForObject("/", String::class.java)
assertThat(body).isEqualTo("Hello World")
}
}自定义 WebTestClient
要自定义 WebTestClient bean，请配置一个 WebTestClientBuilderCustomizer bean。任何此类 bean 都会在创建 WebTestClient 时，使用用于构建 WebTestClient 的 WebTestClient.Builder 被调用。
使用 JMX
由于测试上下文框架会缓存上下文，JMX 默认是禁用的，以防止相同的组件注册到同一个域。如果此类测试需要访问 MBeanServer，请考虑将其标记为 dirty。
-
Java
-
Kotlin
import javax.management.MBeanServer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.DirtiesContext;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(properties = "spring.jmx.enabled=true")
@DirtiesContext
class MyJmxTests {
@Autowired
private MBeanServer mBeanServer;
@Test
void exampleTest() {
assertThat(this.mBeanServer.getDomains()).contains("java.lang");
// ...
}
}import javax.management.MBeanServer
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.annotation.DirtiesContext
@SpringBootTest(properties = ["spring.jmx.enabled=true"])
@DirtiesContext
class MyJmxTests(@Autowired val mBeanServer: MBeanServer) {
@Test
fun exampleTest() {
assertThat(mBeanServer.domains).contains("java.lang")
// ...
}
}使用 Observations
如果你使用 @AutoConfigureObservability 注解 切片测试，它会自动配置一个 ObservationRegistry。
使用 Metrics
无论你的 classpath 如何，除了内存支持的 meter registries 外，在使用 @SpringBootTest 时都不会自动配置。
如果你需要将 metrics 导出到其他后端作为集成测试的一部分，请使用 @AutoConfigureObservability 注解进行标注。
如果你使用 @AutoConfigureObservability 注解 切片测试，它会自动配置一个内存型的 MeterRegistry。使用 @AutoConfigureObservability 注解时，不支持在切片测试中导出数据。
使用 Tracing
无论你的 classpath 如何，在使用 @SpringBootTest 时，用于报告数据的 tracing 组件都不会自动配置。
如果你需要将这些组件作为集成测试的一部分，请使用 @AutoConfigureObservability 注解测试。
如果你创建了自己的报告组件（例如自定义的 SpanExporter 或 brave.handler.SpanHandler），并且不希望它们在测试中激活，你可以使用 @ConditionalOnEnabledTracing 注解来禁用它们。
如果你使用 @AutoConfigureObservability 注解 切片测试，它会自动配置一个 no-op Tracer。使用 @AutoConfigureObservability 注解时，不支持在切片测试中导出数据。
Mocking 和 Spying Beans
运行测试时，有时需要模拟应用程序上下文中的某些组件。例如，你可能有一个远程服务的门面 (facade)，该服务在开发期间不可用。模拟 (Mocking) 也可以在你想要模拟在真实环境中难以触发的故障时非常有用。
Spring Framework 包含 @MockitoBean 注解，可用于在你的 ApplicationContext 中为 bean 定义一个 Mockito mock。此外，@MockitoSpyBean 可用于定义一个 Mockito spy。在Spring Framework 文档中了解有关这些功能的更多信息。
自动配置测试
Spring Boot 的自动配置系统对于应用程序来说很好，但有时对于测试来说可能有点过多。通常只加载测试应用程序“切片”所需的配置部分会很有帮助。例如，你可能想要测试 Spring MVC 控制器是否正确映射 URL，并且不希望在这些测试中涉及数据库调用；或者你可能想要测试 JPA 实体，并且在这些测试运行时对 Web 层不感兴趣。
spring-boot-test-autoconfigure 模块包含许多可用于自动配置此类“切片”的注解。它们都以类似的方式工作，提供一个加载 ApplicationContext 的 @…Test 注解，以及一个或多个可用于自定义自动配置设置的 @AutoConfigure… 注解。
每个切片都会限制组件扫描到适当的组件，并加载一组非常有限的自动配置类。如果你需要排除其中一个，大多数 @…Test 注解都提供一个 excludeAutoConfiguration 属性。或者，你可以使用 @ImportAutoConfiguration#exclude。 |
不支持在同一个测试中使用多个 @…Test 注解来包含多个“切片”。如果你需要多个“切片”，请选择一个 @…Test 注解，然后手动包含其他“切片”的 @AutoConfigure… 注解。 |
也可以将 @AutoConfigure… 注解与标准的 @SpringBootTest 注解一起使用。如果你对应用程序的“切片”不感兴趣，但需要一些自动配置的测试 bean，可以使用这种组合。 |
自动配置的 JSON 测试
-
Jackson
ObjectMapper、任何@JsonComponentbean 以及任何 JacksonModule -
Gson -
Jsonb
如果你需要配置自动配置的元素，可以使用 @AutoConfigureJsonTesters 注解。
Spring Boot 包含基于 AssertJ 的 helper 类，它们与 JSONAssert 和 JsonPath 库配合使用，以检查 JSON 是否按预期出现。JacksonTester、GsonTester、JsonbTester 和 BasicJsonTester 类可分别用于 Jackson、Gson、Jsonb 和字符串。在使用 @JsonTest 时，测试类中的任何 helper 字段都可以被 @Autowired 注入。下面的示例显示了用于 Jackson 的测试类
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.json.JsonTest;
import org.springframework.boot.test.json.JacksonTester;
import static org.assertj.core.api.Assertions.assertThat;
@JsonTest
class MyJsonTests {
@Autowired
private JacksonTester<VehicleDetails> json;
@Test
void serialize() throws Exception {
VehicleDetails details = new VehicleDetails("Honda", "Civic");
// Assert against a `.json` file in the same package as the test
assertThat(this.json.write(details)).isEqualToJson("expected.json");
// Or use JSON path based assertions
assertThat(this.json.write(details)).hasJsonPathStringValue("@.make");
assertThat(this.json.write(details)).extractingJsonPathStringValue("@.make").isEqualTo("Honda");
}
@Test
void deserialize() throws Exception {
String content = "{\"make\":\"Ford\",\"model\":\"Focus\"}";
assertThat(this.json.parse(content)).isEqualTo(new VehicleDetails("Ford", "Focus"));
assertThat(this.json.parseObject(content).getMake()).isEqualTo("Ford");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.json.JsonTest
import org.springframework.boot.test.json.JacksonTester
@JsonTest
class MyJsonTests(@Autowired val json: JacksonTester<VehicleDetails>) {
@Test
fun serialize() {
val details = VehicleDetails("Honda", "Civic")
// Assert against a `.json` file in the same package as the test
assertThat(json.write(details)).isEqualToJson("expected.json")
// Or use JSON path based assertions
assertThat(json.write(details)).hasJsonPathStringValue("@.make")
assertThat(json.write(details)).extractingJsonPathStringValue("@.make").isEqualTo("Honda")
}
@Test
fun deserialize() {
val content = "{\"make\":\"Ford\",\"model\":\"Focus\"}"
assertThat(json.parse(content)).isEqualTo(VehicleDetails("Ford", "Focus"))
assertThat(json.parseObject(content).make).isEqualTo("Ford")
}
}JSON helper 类也可以直接用于标准单元测试。为此，如果你不使用 @JsonTest，请在你的 @BeforeEach 方法中调用 helper 的 initFields 方法。 |
如果你使用 Spring Boot 基于 AssertJ 的 helper 类来对给定 JSON 路径下的数值进行断言，根据类型不同，你可能无法使用 isEqualTo。相反，你可以使用 AssertJ 的 satisfies 来断言该值符合给定条件。例如，下面的示例断言实际数值是一个接近 0.15 且偏移量在 0.01 之内的浮点值。
-
Java
-
Kotlin
@Test
void someTest() throws Exception {
SomeObject value = new SomeObject(0.152f);
assertThat(this.json.write(value)).extractingJsonPathNumberValue("@.test.numberValue")
.satisfies((number) -> assertThat(number.floatValue()).isCloseTo(0.15f, within(0.01f)));
} @Test
fun someTest() {
val value = SomeObject(0.152f)
assertThat(json.write(value)).extractingJsonPathNumberValue("@.test.numberValue")
.satisfies(ThrowingConsumer { number ->
assertThat(number.toFloat()).isCloseTo(0.15f, within(0.01f))
})
}自动配置的 Spring MVC 测试
要测试 Spring MVC 控制器是否按预期工作，使用 @WebMvcTest 注解。@WebMvcTest 会自动配置 Spring MVC 基础设施，并将扫描的 bean 限制为 @Controller、@ControllerAdvice、@JsonComponent、Converter、GenericConverter、Filter、HandlerInterceptor、WebMvcConfigurer、WebMvcRegistrations 和 HandlerMethodArgumentResolver。使用 @WebMvcTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
@WebMvcTest 启用的自动配置设置列表可以在附录中找到。 |
通常，@WebMvcTest 仅限于单个控制器，并与 @MockitoBean 结合使用，为所需的协作对象提供 mock 实现。
@WebMvcTest 也会自动配置 MockMvc。Mock MVC 提供了一种强大的方法，无需启动完整的 HTTP 服务器即可快速测试 MVC 控制器。如果 AssertJ 可用，MockMvcTester 提供的 AssertJ 支持也会自动配置。
你也可以通过使用 @AutoConfigureMockMvc 注解，在非 @WebMvcTest 测试（例如 @SpringBootTest）中自动配置 MockMvc 和 MockMvcTester。下面的示例使用了 MockMvcTester |
-
Java
-
Kotlin
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.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
@WebMvcTest(UserVehicleController.class)
class MyControllerTests {
@Autowired
private MockMvcTester mvc;
@MockitoBean
private UserVehicleService userVehicleService;
@Test
void testExample() {
given(this.userVehicleService.getVehicleDetails("sboot"))
.willReturn(new VehicleDetails("Honda", "Civic"));
assertThat(this.mvc.get().uri("/sboot/vehicle").accept(MediaType.TEXT_PLAIN))
.hasStatusOk()
.hasBodyTextEqualTo("Honda Civic");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.mockito.BDDMockito.given
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.http.MediaType
import org.springframework.test.context.bean.override.mockito.MockitoBean
import org.springframework.test.web.servlet.assertj.MockMvcTester
@WebMvcTest(UserVehicleController::class)
class MyControllerTests(@Autowired val mvc: MockMvcTester) {
@MockitoBean
lateinit var userVehicleService: UserVehicleService
@Test
fun testExample() {
given(userVehicleService.getVehicleDetails("sboot"))
.willReturn(VehicleDetails("Honda", "Civic"))
assertThat(mvc.get().uri("/sboot/vehicle").accept(MediaType.TEXT_PLAIN))
.hasStatusOk().hasBodyTextEqualTo("Honda Civic")
}
}如果你需要配置自动配置的元素（例如，何时应用 servlet filter），可以使用 @AutoConfigureMockMvc 注解中的属性。 |
如果你使用 HtmlUnit 和 Selenium，自动配置也会提供一个 HtmlUnit WebClient bean 和/或一个 Selenium WebDriver bean。下面的示例使用了 HtmlUnit
-
Java
-
Kotlin
import org.htmlunit.WebClient;
import org.htmlunit.html.HtmlPage;
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.context.bean.override.mockito.MockitoBean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
@WebMvcTest(UserVehicleController.class)
class MyHtmlUnitTests {
@Autowired
private WebClient webClient;
@MockitoBean
private UserVehicleService userVehicleService;
@Test
void testExample() throws Exception {
given(this.userVehicleService.getVehicleDetails("sboot")).willReturn(new VehicleDetails("Honda", "Civic"));
HtmlPage page = this.webClient.getPage("/sboot/vehicle.html");
assertThat(page.getBody().getTextContent()).isEqualTo("Honda Civic");
}
}import org.assertj.core.api.Assertions.assertThat
import org.htmlunit.WebClient
import org.htmlunit.html.HtmlPage
import org.junit.jupiter.api.Test
import org.mockito.BDDMockito.given
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.test.context.bean.override.mockito.MockitoBean
@WebMvcTest(UserVehicleController::class)
class MyHtmlUnitTests(@Autowired val webClient: WebClient) {
@MockitoBean
lateinit var userVehicleService: UserVehicleService
@Test
fun testExample() {
given(userVehicleService.getVehicleDetails("sboot")).willReturn(VehicleDetails("Honda", "Civic"))
val page = webClient.getPage<HtmlPage>("/sboot/vehicle.html")
assertThat(page.body.textContent).isEqualTo("Honda Civic")
}
}默认情况下，Spring Boot 将 WebDriver bean 放入一个特殊的“scope”中，以确保 driver 在每个测试后退出并注入新的实例。如果你不想要此行为，可以将 @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON) 添加到你的 WebDriver @Bean 定义中。 |
Spring Boot 创建的 webDriver scope 将替换任何用户定义的同名 scope。如果你定义了自己的 webDriver scope，你可能会发现当使用 @WebMvcTest 时它会停止工作。 |
如果你的 classpath 中有 Spring Security，@WebMvcTest 也会扫描 WebSecurityConfigurer bean。你可以使用 Spring Security 的测试支持，而不是为此类测试完全禁用安全性。有关如何使用 Spring Security 的 MockMvc 支持的更多详细信息，可以在此使用 Spring Security 进行测试 “How-to Guides” 部分中找到。
| 有时编写 Spring MVC 测试还不够；Spring Boot 可以帮助你运行使用实际服务器进行完整的端到端测试。 |
自动配置的 Spring WebFlux 测试
要测试 Spring WebFlux 控制器是否按预期工作，你可以使用 @WebFluxTest 注解。@WebFluxTest 会自动配置 Spring WebFlux 基础设施，并将扫描的 bean 限制为 @Controller、@ControllerAdvice、@JsonComponent、Converter、GenericConverter 和 WebFluxConfigurer。使用 @WebFluxTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
@WebFluxTest 启用的自动配置列表可以在附录中找到。 |
通常，@WebFluxTest 仅限于单个控制器，并与 @MockitoBean 注解结合使用，为所需的协作对象提供 mock 实现。
@WebFluxTest 也会自动配置 WebTestClient，它提供了一种强大的方法，无需启动完整的 HTTP 服务器即可快速测试 WebFlux 控制器。
你也可以通过使用 @AutoConfigureWebTestClient 注解，在非 @WebFluxTest 测试（例如 @SpringBootTest）中自动配置 WebTestClient。下面的示例显示了一个同时使用了 @WebFluxTest 和 WebTestClient 的类 |
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.bean.override.mockito.MockitoBean;
import org.springframework.test.web.reactive.server.WebTestClient;
import static org.mockito.BDDMockito.given;
@WebFluxTest(UserVehicleController.class)
class MyControllerTests {
@Autowired
private WebTestClient webClient;
@MockitoBean
private UserVehicleService userVehicleService;
@Test
void testExample() {
given(this.userVehicleService.getVehicleDetails("sboot"))
.willReturn(new VehicleDetails("Honda", "Civic"));
this.webClient.get().uri("/sboot/vehicle").accept(MediaType.TEXT_PLAIN).exchange()
.expectStatus().isOk()
.expectBody(String.class).isEqualTo("Honda Civic");
}
}import org.junit.jupiter.api.Test
import org.mockito.BDDMockito.given
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest
import org.springframework.http.MediaType
import org.springframework.test.context.bean.override.mockito.MockitoBean
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
@WebFluxTest(UserVehicleController::class)
class MyControllerTests(@Autowired val webClient: WebTestClient) {
@MockitoBean
lateinit var userVehicleService: UserVehicleService
@Test
fun testExample() {
given(userVehicleService.getVehicleDetails("sboot"))
.willReturn(VehicleDetails("Honda", "Civic"))
webClient.get().uri("/sboot/vehicle").accept(MediaType.TEXT_PLAIN).exchange()
.expectStatus().isOk
.expectBody<String>().isEqualTo("Honda Civic")
}
}此设置仅受 WebFlux 应用程序支持，因为目前在模拟的 Web 应用程序中使用 WebTestClient 只适用于 WebFlux。 |
@WebFluxTest 无法检测通过函数式 Web 框架注册的路由。要测试上下文中的 RouterFunction bean，请考虑通过使用 @Import 或使用 @SpringBootTest 来导入你自己的 RouterFunction。 |
@WebFluxTest 无法检测注册为类型为 SecurityWebFilterChain 的 @Bean 的自定义安全配置。要将其包含在测试中，你需要通过使用 @Import 或使用 @SpringBootTest 导入注册该 bean 的配置。 |
| 有时编写 Spring WebFlux 测试还不够；Spring Boot 可以帮助你运行使用实际服务器进行完整的端到端测试。 |
自动配置的 Spring GraphQL 测试
Spring GraphQL 提供了一个专用的测试支持模块；你需要将其添加到你的项目中
<dependencies>
<dependency>
<groupId>org.springframework.graphql</groupId>
<artifactId>spring-graphql-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Unless already present in the compile scope -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
<scope>test</scope>
</dependency>
</dependencies>dependencies {
testImplementation("org.springframework.graphql:spring-graphql-test")
// Unless already present in the implementation configuration
testImplementation("org.springframework.boot:spring-boot-starter-webflux")
}这个测试模块提供了 GraphQlTester。这个 tester 在测试中被大量使用，所以请务必熟悉它的用法。有不同变种的 GraphQlTester，Spring Boot 会根据测试类型自动配置它们
-
ExecutionGraphQlServiceTester在服务端执行测试，不涉及客户端或传输层 -
HttpGraphQlTester使用连接到服务器的客户端执行测试，无论服务器是否正在运行。
Spring Boot 通过 @GraphQlTest 注解帮助你测试你的 Spring GraphQL Controller。@GraphQlTest 会自动配置 Spring GraphQL 基础设施，不涉及任何传输或服务器。这将扫描的 bean 限制为 @Controller、RuntimeWiringConfigurer、JsonComponent、Converter、GenericConverter、DataFetcherExceptionResolver、Instrumentation 和 GraphQlSourceBuilderCustomizer。使用 @GraphQlTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
@GraphQlTest 启用的自动配置列表可以在附录中找到。 |
通常，@GraphQlTest 仅限于一组控制器，并与 @MockitoBean 注解结合使用，为所需的协作对象提供 mock 实现。
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.docs.web.graphql.runtimewiring.GreetingController;
import org.springframework.boot.test.autoconfigure.graphql.GraphQlTest;
import org.springframework.graphql.test.tester.GraphQlTester;
@GraphQlTest(GreetingController.class)
class GreetingControllerTests {
@Autowired
private GraphQlTester graphQlTester;
@Test
void shouldGreetWithSpecificName() {
this.graphQlTester.document("{ greeting(name: \"Alice\") } ")
.execute()
.path("greeting")
.entity(String.class)
.isEqualTo("Hello, Alice!");
}
@Test
void shouldGreetWithDefaultName() {
this.graphQlTester.document("{ greeting } ")
.execute()
.path("greeting")
.entity(String.class)
.isEqualTo("Hello, Spring!");
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.docs.web.graphql.runtimewiring.GreetingController
import org.springframework.boot.test.autoconfigure.graphql.GraphQlTest
import org.springframework.graphql.test.tester.GraphQlTester
@GraphQlTest(GreetingController::class)
internal class GreetingControllerTests {
@Autowired
lateinit var graphQlTester: GraphQlTester
@Test
fun shouldGreetWithSpecificName() {
graphQlTester.document("{ greeting(name: \"Alice\") } ").execute().path("greeting").entity(String::class.java)
.isEqualTo("Hello, Alice!")
}
@Test
fun shouldGreetWithDefaultName() {
graphQlTester.document("{ greeting } ").execute().path("greeting").entity(String::class.java)
.isEqualTo("Hello, Spring!")
}
}@SpringBootTest 测试是完整的集成测试，涉及整个应用程序。使用随机端口或指定端口时，会配置 live server，并自动贡献一个 HttpGraphQlTester bean，这样你就可以用它来测试你的服务器。配置 MOCK 环境时，你也可以通过使用 @AutoConfigureHttpGraphQlTester 注解测试类来请求一个 HttpGraphQlTester bean
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.graphql.tester.AutoConfigureHttpGraphQlTester;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.graphql.test.tester.HttpGraphQlTester;
@AutoConfigureHttpGraphQlTester
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
class GraphQlIntegrationTests {
@Test
void shouldGreetWithSpecificName(@Autowired HttpGraphQlTester graphQlTester) {
HttpGraphQlTester authenticatedTester = graphQlTester.mutate()
.webTestClient((client) -> client.defaultHeaders((headers) -> headers.setBasicAuth("admin", "ilovespring")))
.build();
authenticatedTester.document("{ greeting(name: \"Alice\") } ")
.execute()
.path("greeting")
.entity(String.class)
.isEqualTo("Hello, Alice!");
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.graphql.tester.AutoConfigureHttpGraphQlTester
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.graphql.test.tester.HttpGraphQlTester
import org.springframework.http.HttpHeaders
import org.springframework.test.web.reactive.server.WebTestClient
@AutoConfigureHttpGraphQlTester
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
class GraphQlIntegrationTests {
@Test
fun shouldGreetWithSpecificName(@Autowired graphQlTester: HttpGraphQlTester) {
val authenticatedTester = graphQlTester.mutate()
.webTestClient { client: WebTestClient.Builder ->
client.defaultHeaders { headers: HttpHeaders ->
headers.setBasicAuth("admin", "ilovespring")
}
}.build()
authenticatedTester.document("{ greeting(name: \"Alice\") } ").execute()
.path("greeting").entity(String::class.java).isEqualTo("Hello, Alice!")
}
}自动配置的 Data Cassandra 测试
你可以使用 @DataCassandraTest 来测试 Cassandra 应用程序。默认情况下，它配置一个 CassandraTemplate，扫描 @Table 类，并配置 Spring Data Cassandra repositories。使用 @DataCassandraTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Cassandra 的更多信息，请参阅Cassandra。）
@DataCassandraTest 启用的自动配置设置列表可以在附录中找到。 |
下面的示例显示了在 Spring Boot 中使用 Cassandra 测试的典型设置
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.cassandra.DataCassandraTest;
@DataCassandraTest
class MyDataCassandraTests {
@Autowired
private SomeRepository repository;
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.cassandra.DataCassandraTest
@DataCassandraTest
class MyDataCassandraTests(@Autowired val repository: SomeRepository)自动配置的 Data Couchbase 测试
你可以使用 @DataCouchbaseTest 来测试 Couchbase 应用程序。默认情况下，它配置一个 CouchbaseTemplate 或一个 ReactiveCouchbaseTemplate，扫描 @Document 类，并配置 Spring Data Couchbase repositories。使用 @DataCouchbaseTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Couchbase 的更多信息，请参阅Couchbase。）
@DataCouchbaseTest 启用的自动配置设置列表可以在附录中找到。 |
下面的示例显示了在 Spring Boot 中使用 Couchbase 测试的典型设置
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.couchbase.DataCouchbaseTest;
@DataCouchbaseTest
class MyDataCouchbaseTests {
@Autowired
private SomeRepository repository;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.couchbase.DataCouchbaseTest
@DataCouchbaseTest
class MyDataCouchbaseTests(@Autowired val repository: SomeRepository) {
// ...
}自动配置的 Data Elasticsearch 测试
你可以使用 @DataElasticsearchTest 来测试 Elasticsearch 应用程序。默认情况下，它配置一个 ElasticsearchTemplate，扫描 @Document 类，并配置 Spring Data Elasticsearch repositories。使用 @DataElasticsearchTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Elasticsearch 的更多信息，请参阅Elasticsearch。）
@DataElasticsearchTest 启用的自动配置设置列表可以在附录中找到。 |
下面的示例显示了在 Spring Boot 中使用 Elasticsearch 测试的典型设置
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.elasticsearch.DataElasticsearchTest;
@DataElasticsearchTest
class MyDataElasticsearchTests {
@Autowired
private SomeRepository repository;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.elasticsearch.DataElasticsearchTest
@DataElasticsearchTest
class MyDataElasticsearchTests(@Autowired val repository: SomeRepository) {
// ...
}自动配置的 Data JPA 测试
你可以使用 @DataJpaTest 注解来测试 JPA 应用程序。默认情况下，它扫描 @Entity 类并配置 Spring Data JPA repositories。如果 classpath 中有嵌入式数据库，它也会配置一个。通过将 spring.jpa.show-sql 属性设置为 true，SQL 查询默认会被记录。可以使用注解的 showSql 属性禁用此功能。
使用 @DataJpaTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
@DataJpaTest 启用的自动配置设置列表可以在附录中找到。 |
默认情况下，Data JPA 测试是事务性的，并在每个测试结束时回滚。更多详细信息，请参阅 Spring Framework 参考文档中的相关章节。如果这不是你想要的，可以按如下方式为单个测试或整个类禁用事务管理
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@DataJpaTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyNonTransactionalTests {
// ...
}import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
@DataJpaTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyNonTransactionalTests {
// ...
}Data JPA 测试也可能注入一个 TestEntityManager bean，它提供了标准 JPA EntityManager 的替代方案，专为测试设计。
TestEntityManager 也可以通过添加 @AutoConfigureTestEntityManager，自动配置到你的任何基于 Spring 的测试类中。进行此操作时，请确保你的测试运行在事务中，例如通过在测试类或方法上添加 @Transactional。 |
如果你需要 JdbcTemplate，它也是可用的。下面的示例展示了正在使用的 @DataJpaTest 注解
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import static org.assertj.core.api.Assertions.assertThat;
@DataJpaTest
class MyRepositoryTests {
@Autowired
private TestEntityManager entityManager;
@Autowired
private UserRepository repository;
@Test
void testExample() {
this.entityManager.persist(new User("sboot", "1234"));
User user = this.repository.findByUsername("sboot");
assertThat(user.getUsername()).isEqualTo("sboot");
assertThat(user.getEmployeeNumber()).isEqualTo("1234");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager
@DataJpaTest
class MyRepositoryTests(@Autowired val entityManager: TestEntityManager, @Autowired val repository: UserRepository) {
@Test
fun testExample() {
entityManager.persist(User("sboot", "1234"))
val user = repository.findByUsername("sboot")
assertThat(user?.username).isEqualTo("sboot")
assertThat(user?.employeeNumber).isEqualTo("1234")
}
}内存中的嵌入式数据库通常很适合用于测试，因为它们速度快且不需要任何安装。然而，如果您希望针对真实的数据库运行测试，可以使用 @AutoConfigureTestDatabase 注解，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase.Replace;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
@DataJpaTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
class MyRepositoryTests {
// ...
}import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class MyRepositoryTests {
// ...
}自动配置的 JDBC 测试
@JdbcTest 类似于 @DataJpaTest，但适用于仅需要 DataSource 而不使用 Spring Data JDBC 的测试。默认情况下，它配置一个内存嵌入式数据库和一个 JdbcTemplate。当使用 @JdbcTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
默认情况下，JDBC 测试是事务性的，并在每个测试结束时回滚。更多详情请参见 Spring Framework 参考文档中的相关部分。如果这不是您想要的行为，可以为某个测试或整个类禁用事务管理，如下所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@JdbcTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyTransactionalTests {
}import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
@JdbcTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyTransactionalTests如果您希望测试针对真实的数据库运行，可以使用 @AutoConfigureTestDatabase 注解，用法与 @DataJpaTest 相同。（参见自动配置的 Data JPA 测试。）
自动配置的 Data JDBC 测试
@DataJdbcTest 类似于 @JdbcTest，但适用于使用 Spring Data JDBC 仓库的测试。默认情况下，它配置一个内存嵌入式数据库、一个 JdbcTemplate 和 Spring Data JDBC 仓库。当使用 @DataJdbcTest 注解时，只会扫描 AbstractJdbcConfiguration 的子类，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
由 @DataJdbcTest 启用的自动配置列表在附录中可以找到。 |
默认情况下，Data JDBC 测试是事务性的，并在每个测试结束时回滚。更多详情请参见 Spring Framework 参考文档中的相关部分。如果这不是您想要的行为，可以为某个测试或整个测试类禁用事务管理，如JDBC 示例中所示。
如果您希望测试针对真实的数据库运行，可以使用 @AutoConfigureTestDatabase 注解，用法与 @DataJpaTest 相同。（参见自动配置的 Data JPA 测试。）
自动配置的 Data R2DBC 测试
@DataR2dbcTest 类似于 @DataJdbcTest，但适用于使用 Spring Data R2DBC 仓库的测试。默认情况下，它配置一个内存嵌入式数据库、一个 R2dbcEntityTemplate 和 Spring Data R2DBC 仓库。当使用 @DataR2dbcTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
由 @DataR2dbcTest 启用的自动配置设置列表在附录中可以找到。 |
默认情况下，Data R2DBC 测试不是事务性的。
如果您希望测试针对真实的数据库运行，可以使用 @AutoConfigureTestDatabase 注解，用法与 @DataJpaTest 相同。（参见自动配置的 Data JPA 测试。）
自动配置的 jOOQ 测试
您可以像使用 @JdbcTest 一样使用 @JooqTest，但它用于 jOOQ 相关的测试。由于 jOOQ 严重依赖于与数据库模式相对应的基于 Java 的模式，因此会使用现有的 DataSource。如果您想用内存数据库替换它，可以使用 @AutoConfigureTestDatabase 来覆盖这些设置。（更多关于在 Spring Boot 中使用 jOOQ 的信息，请参见使用 jOOQ。）当使用 @JooqTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
@JooqTest 配置了一个 DSLContext。以下示例展示了 @JooqTest 注解的使用方法
-
Java
-
Kotlin
import org.jooq.DSLContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jooq.JooqTest;
@JooqTest
class MyJooqTests {
@Autowired
private DSLContext dslContext;
// ...
}import org.jooq.DSLContext
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jooq.JooqTest
@JooqTest
class MyJooqTests(@Autowired val dslContext: DSLContext) {
// ...
}默认情况下，jOOQ 测试是事务性的，并在每个测试结束时回滚。如果这不是您想要的行为，可以为某个测试或整个测试类禁用事务管理，如JDBC 示例中所示。
自动配置的 Data MongoDB 测试
您可以使用 @DataMongoTest 来测试 MongoDB 应用。默认情况下，它配置一个 MongoTemplate，扫描 @Document 类，并配置 Spring Data MongoDB 仓库。当使用 @DataMongoTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（更多关于在 Spring Boot 中使用 MongoDB 的信息，请参见MongoDB。）
由 @DataMongoTest 启用的自动配置设置列表在附录中可以找到。 |
以下类展示了 @DataMongoTest 注解的使用方法
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.data.mongodb.core.MongoTemplate;
@DataMongoTest
class MyDataMongoDbTests {
@Autowired
private MongoTemplate mongoTemplate;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest
import org.springframework.data.mongodb.core.MongoTemplate
@DataMongoTest
class MyDataMongoDbTests(@Autowired val mongoTemplate: MongoTemplate) {
// ...
}自动配置的 Data Neo4j 测试
您可以使用 @DataNeo4jTest 来测试 Neo4j 应用。默认情况下，它扫描 @Node 类，并配置 Spring Data Neo4j 仓库。当使用 @DataNeo4jTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（更多关于在 Spring Boot 中使用 Neo4j 的信息，请参见Neo4j。）
由 @DataNeo4jTest 启用的自动配置设置列表在附录中可以找到。 |
以下示例展示了在 Spring Boot 中使用 Neo4j 测试的典型设置
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
@DataNeo4jTest
class MyDataNeo4jTests {
@Autowired
private SomeRepository repository;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest
@DataNeo4jTest
class MyDataNeo4jTests(@Autowired val repository: SomeRepository) {
// ...
}默认情况下，Data Neo4j 测试是事务性的，并在每个测试结束时回滚。更多详情请参见 Spring Framework 参考文档中的相关部分。如果这不是您想要的行为，可以为某个测试或整个类禁用事务管理，如下所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@DataNeo4jTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyDataNeo4jTests {
}import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
@DataNeo4jTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyDataNeo4jTests响应式访问不支持事务性测试。如果您使用这种风格，则必须按照上述说明配置 @DataNeo4jTest 测试。 |
自动配置的 Data Redis 测试
您可以使用 @DataRedisTest 来测试 Redis 应用。默认情况下，它扫描 @RedisHash 类并配置 Spring Data Redis 仓库。当使用 @DataRedisTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（更多关于在 Spring Boot 中使用 Redis 的信息，请参见Redis。）
由 @DataRedisTest 启用的自动配置设置列表在附录中可以找到。 |
以下示例展示了 @DataRedisTest 注解的使用方法
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.redis.DataRedisTest;
@DataRedisTest
class MyDataRedisTests {
@Autowired
private SomeRepository repository;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.redis.DataRedisTest
@DataRedisTest
class MyDataRedisTests(@Autowired val repository: SomeRepository) {
// ...
}自动配置的 Data LDAP 测试
您可以使用 @DataLdapTest 来测试 LDAP 应用。默认情况下，它配置一个内存嵌入式 LDAP（如果可用）、配置一个 LdapTemplate，扫描 @Entry 类，并配置 Spring Data LDAP 仓库。当使用 @DataLdapTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（更多关于在 Spring Boot 中使用 LDAP 的信息，请参见LDAP。）
由 @DataLdapTest 启用的自动配置设置列表在附录中可以找到。 |
以下示例展示了 @DataLdapTest 注解的使用方法
-
Java
-
Kotlin
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest;
import org.springframework.ldap.core.LdapTemplate;
@DataLdapTest
class MyDataLdapTests {
@Autowired
private LdapTemplate ldapTemplate;
// ...
}import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest
import org.springframework.ldap.core.LdapTemplate
@DataLdapTest
class MyDataLdapTests(@Autowired val ldapTemplate: LdapTemplate) {
// ...
}内存嵌入式 LDAP 通常很适合用于测试，因为它速度快且不需要开发人员进行任何安装。然而，如果您希望针对真实的 LDAP 服务器运行测试，则应排除嵌入式 LDAP 的自动配置，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest;
@DataLdapTest(excludeAutoConfiguration = EmbeddedLdapAutoConfiguration.class)
class MyDataLdapTests {
// ...
}import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest
@DataLdapTest(excludeAutoConfiguration = [EmbeddedLdapAutoConfiguration::class])
class MyDataLdapTests {
// ...
}自动配置的 REST 客户端
您可以使用 @RestClientTest 注解来测试 REST 客户端。默认情况下，它自动配置 Jackson、GSON 和 Jsonb 支持，配置一个 RestTemplateBuilder 和一个 RestClient.Builder，并添加对 MockRestServiceServer 的支持。当使用 @RestClientTest 注解时，不会扫描常规的 @Component 和 @ConfigurationProperties bean。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。
由 @RestClientTest 启用的自动配置设置列表在附录中可以找到。 |
您要测试的特定 bean 应通过使用 @RestClientTest 的 value 或 components 属性来指定。
当在被测试的 bean 中使用 RestTemplateBuilder 并且在构建 RestTemplate 时调用了 RestTemplateBuilder.rootUri(String rootUri)，则根 URI 应从 MockRestServiceServer 期望中省略，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.client.MockRestServiceServer;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
@RestClientTest(org.springframework.boot.docs.testing.springbootapplications.autoconfiguredrestclient.RemoteVehicleDetailsService.class)
class MyRestTemplateServiceTests {
@Autowired
private RemoteVehicleDetailsService service;
@Autowired
private MockRestServiceServer server;
@Test
void getVehicleDetailsWhenResultIsSuccessShouldReturnDetails() {
this.server.expect(requestTo("/greet/details")).andRespond(withSuccess("hello", MediaType.TEXT_PLAIN));
String greeting = this.service.callRestService();
assertThat(greeting).isEqualTo("hello");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.client.RestClientTest
import org.springframework.http.MediaType
import org.springframework.test.web.client.MockRestServiceServer
import org.springframework.test.web.client.match.MockRestRequestMatchers
import org.springframework.test.web.client.response.MockRestResponseCreators
@RestClientTest(RemoteVehicleDetailsService::class)
class MyRestTemplateServiceTests(
@Autowired val service: RemoteVehicleDetailsService,
@Autowired val server: MockRestServiceServer) {
@Test
fun getVehicleDetailsWhenResultIsSuccessShouldReturnDetails() {
server.expect(MockRestRequestMatchers.requestTo("/greet/details"))
.andRespond(MockRestResponseCreators.withSuccess("hello", MediaType.TEXT_PLAIN))
val greeting = service.callRestService()
assertThat(greeting).isEqualTo("hello")
}
}当在被测试的 bean 中使用 RestClient.Builder，或者使用 RestTemplateBuilder 但没有调用 rootUri(String rootURI) 时，必须在 MockRestServiceServer 期望中使用完整的 URI，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.client.RestClientTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.client.MockRestServiceServer;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
import static org.springframework.test.web.client.response.MockRestResponseCreators.withSuccess;
@RestClientTest(RemoteVehicleDetailsService.class)
class MyRestClientServiceTests {
@Autowired
private RemoteVehicleDetailsService service;
@Autowired
private MockRestServiceServer server;
@Test
void getVehicleDetailsWhenResultIsSuccessShouldReturnDetails() {
this.server.expect(requestTo("https://example.com/greet/details"))
.andRespond(withSuccess("hello", MediaType.TEXT_PLAIN));
String greeting = this.service.callRestService();
assertThat(greeting).isEqualTo("hello");
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.client.RestClientTest
import org.springframework.http.MediaType
import org.springframework.test.web.client.MockRestServiceServer
import org.springframework.test.web.client.match.MockRestRequestMatchers
import org.springframework.test.web.client.response.MockRestResponseCreators
@RestClientTest(RemoteVehicleDetailsService::class)
class MyRestClientServiceTests(
@Autowired val service: RemoteVehicleDetailsService,
@Autowired val server: MockRestServiceServer) {
@Test
fun getVehicleDetailsWhenResultIsSuccessShouldReturnDetails() {
server.expect(MockRestRequestMatchers.requestTo("https://example.com/greet/details"))
.andRespond(MockRestResponseCreators.withSuccess("hello", MediaType.TEXT_PLAIN))
val greeting = service.callRestService()
assertThat(greeting).isEqualTo("hello")
}
}自动配置的 Spring REST Docs 测试
您可以使用 @AutoConfigureRestDocs 注解在您的测试中使用 Spring REST Docs，支持 Mock MVC、REST Assured 或 WebTestClient。它消除了 Spring REST Docs 中对 JUnit 扩展的需求。
@AutoConfigureRestDocs 可用于覆盖默认的输出目录（如果使用 Maven 则为 target/generated-snippets，如果使用 Gradle 则为 build/generated-snippets）。它还可以用于配置出现在任何文档化 URI 中的主机、方案和端口。
使用 Mock MVC 的自动配置 Spring REST Docs 测试
@AutoConfigureRestDocs 会定制 MockMvc bean，以便在测试基于 Servlet 的 Web 应用时使用 Spring REST Docs。您可以使用 @Autowired 注入它，并在测试中使用它，就像您通常使用 Mock MVC 和 Spring REST Docs 时一样，如下例所示
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
@WebMvcTest(UserController.class)
@AutoConfigureRestDocs
class MyUserDocumentationTests {
@Autowired
private MockMvcTester mvc;
@Test
void listUsers() {
assertThat(this.mvc.get().uri("/users").accept(MediaType.TEXT_PLAIN)).hasStatusOk()
.apply(document("list-users"));
}
}如果您更喜欢使用 AssertJ 集成，MockMvcTester 也可用，如下例所示
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.assertj.MockMvcTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
@WebMvcTest(UserController.class)
@AutoConfigureRestDocs
class MyUserDocumentationTests {
@Autowired
private MockMvcTester mvc;
@Test
void listUsers() {
assertThat(this.mvc.get().uri("/users").accept(MediaType.TEXT_PLAIN)).hasStatusOk()
.apply(document("list-users"));
}
}两者在后台重用相同的 MockMvc 实例，因此对其进行的任何配置都适用于两者。
如果您需要比 @AutoConfigureRestDocs 属性提供的对 Spring REST Docs 配置更多的控制，可以使用 RestDocsMockMvcConfigurationCustomizer bean，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.restdocs.RestDocsMockMvcConfigurationCustomizer;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.restdocs.mockmvc.MockMvcRestDocumentationConfigurer;
import org.springframework.restdocs.templates.TemplateFormats;
@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsMockMvcConfigurationCustomizer {
@Override
public void customize(MockMvcRestDocumentationConfigurer configurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
}
}import org.springframework.boot.test.autoconfigure.restdocs.RestDocsMockMvcConfigurationCustomizer
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.restdocs.mockmvc.MockMvcRestDocumentationConfigurer
import org.springframework.restdocs.templates.TemplateFormats
@TestConfiguration(proxyBeanMethods = false)
class MyRestDocsConfiguration : RestDocsMockMvcConfigurationCustomizer {
override fun customize(configurer: MockMvcRestDocumentationConfigurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown())
}
}如果您想利用 Spring REST Docs 对参数化输出目录的支持，可以创建一个 RestDocumentationResultHandler bean。自动配置会使用此结果处理器调用 alwaysDo，从而导致每次 MockMvc 调用都自动生成默认片段。以下示例展示了如何定义 RestDocumentationResultHandler
-
Java
-
Kotlin
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.restdocs.mockmvc.MockMvcRestDocumentation;
import org.springframework.restdocs.mockmvc.RestDocumentationResultHandler;
@TestConfiguration(proxyBeanMethods = false)
public class MyResultHandlerConfiguration {
@Bean
public RestDocumentationResultHandler restDocumentation() {
return MockMvcRestDocumentation.document("{method-name}");
}
}import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.restdocs.mockmvc.MockMvcRestDocumentation
import org.springframework.restdocs.mockmvc.RestDocumentationResultHandler
@TestConfiguration(proxyBeanMethods = false)
class MyResultHandlerConfiguration {
@Bean
fun restDocumentation(): RestDocumentationResultHandler {
return MockMvcRestDocumentation.document("{method-name}")
}
}使用 WebTestClient 的自动配置 Spring REST Docs 测试
@AutoConfigureRestDocs 在测试响应式 Web 应用时也可与 WebTestClient 一起使用。您可以使用 @Autowired 注入它，并在您的测试中使用它，就像您通常使用 @WebFluxTest 和 Spring REST Docs 时一样，如下例所示
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.test.web.reactive.server.WebTestClient;
import static org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation.document;
@WebFluxTest
@AutoConfigureRestDocs
class MyUsersDocumentationTests {
@Autowired
private WebTestClient webTestClient;
@Test
void listUsers() {
this.webTestClient
.get().uri("/")
.exchange()
.expectStatus()
.isOk()
.expectBody()
.consumeWith(document("list-users"));
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest
import org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation
import org.springframework.test.web.reactive.server.WebTestClient
@WebFluxTest
@AutoConfigureRestDocs
class MyUsersDocumentationTests(@Autowired val webTestClient: WebTestClient) {
@Test
fun listUsers() {
webTestClient
.get().uri("/")
.exchange()
.expectStatus()
.isOk
.expectBody()
.consumeWith(WebTestClientRestDocumentation.document("list-users"))
}
}如果您需要比 @AutoConfigureRestDocs 属性提供的对 Spring REST Docs 配置更多的控制，可以使用 RestDocsWebTestClientConfigurationCustomizer bean，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.restdocs.RestDocsWebTestClientConfigurationCustomizer;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.restdocs.webtestclient.WebTestClientRestDocumentationConfigurer;
@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsWebTestClientConfigurationCustomizer {
@Override
public void customize(WebTestClientRestDocumentationConfigurer configurer) {
configurer.snippets().withEncoding("UTF-8");
}
}import org.springframework.boot.test.autoconfigure.restdocs.RestDocsWebTestClientConfigurationCustomizer
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.restdocs.webtestclient.WebTestClientRestDocumentationConfigurer
@TestConfiguration(proxyBeanMethods = false)
class MyRestDocsConfiguration : RestDocsWebTestClientConfigurationCustomizer {
override fun customize(configurer: WebTestClientRestDocumentationConfigurer) {
configurer.snippets().withEncoding("UTF-8")
}
}如果您想利用 Spring REST Docs 对参数化输出目录的支持，可以使用 WebTestClientBuilderCustomizer 为每个实体交换结果配置一个消费者。以下示例展示了如何定义这样的 WebTestClientBuilderCustomizer
-
Java
-
Kotlin
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.test.web.reactive.server.WebTestClientBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import static org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation.document;
@TestConfiguration(proxyBeanMethods = false)
public class MyWebTestClientBuilderCustomizerConfiguration {
@Bean
public WebTestClientBuilderCustomizer restDocumentation() {
return (builder) -> builder.entityExchangeResultConsumer(document("{method-name}"));
}
}import org.springframework.boot.test.context.TestConfiguration
import org.springframework.boot.test.web.reactive.server.WebTestClientBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.restdocs.webtestclient.WebTestClientRestDocumentation
import org.springframework.test.web.reactive.server.WebTestClient
@TestConfiguration(proxyBeanMethods = false)
class MyWebTestClientBuilderCustomizerConfiguration {
@Bean
fun restDocumentation(): WebTestClientBuilderCustomizer {
return WebTestClientBuilderCustomizer { builder: WebTestClient.Builder ->
builder.entityExchangeResultConsumer(
WebTestClientRestDocumentation.document("{method-name}")
)
}
}
}使用 REST Assured 的自动配置 Spring REST Docs 测试
@AutoConfigureRestDocs 提供一个预配置为使用 Spring REST Docs 的 RequestSpecification bean 供您在测试中使用。您可以使用 @Autowired 注入它，并在测试中使用它，就像您通常使用 REST Assured 和 Spring REST Docs 时一样，如下例所示
-
Java
-
Kotlin
import io.restassured.specification.RequestSpecification;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.server.LocalServerPort;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.is;
import static org.springframework.restdocs.restassured.RestAssuredRestDocumentation.document;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestDocs
class MyUserDocumentationTests {
@Test
void listUsers(@Autowired RequestSpecification documentationSpec, @LocalServerPort int port) {
given(documentationSpec)
.filter(document("list-users"))
.when()
.port(port)
.get("/")
.then().assertThat()
.statusCode(is(200));
}
}import io.restassured.RestAssured
import io.restassured.specification.RequestSpecification
import org.hamcrest.Matchers
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.restdocs.AutoConfigureRestDocs
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment
import org.springframework.boot.test.web.server.LocalServerPort
import org.springframework.restdocs.restassured.RestAssuredRestDocumentation
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@AutoConfigureRestDocs
class MyUserDocumentationTests {
@Test
fun listUsers(@Autowired documentationSpec: RequestSpecification?, @LocalServerPort port: Int) {
RestAssured.given(documentationSpec)
.filter(RestAssuredRestDocumentation.document("list-users"))
.`when`()
.port(port)["/"]
.then().assertThat()
.statusCode(Matchers.`is`(200))
}
}如果您需要比 @AutoConfigureRestDocs 属性提供的对 Spring REST Docs 配置更多的控制，可以使用 RestDocsRestAssuredConfigurationCustomizer bean，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.test.autoconfigure.restdocs.RestDocsRestAssuredConfigurationCustomizer;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.restdocs.restassured.RestAssuredRestDocumentationConfigurer;
import org.springframework.restdocs.templates.TemplateFormats;
@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsRestAssuredConfigurationCustomizer {
@Override
public void customize(RestAssuredRestDocumentationConfigurer configurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
}
}import org.springframework.boot.test.autoconfigure.restdocs.RestDocsRestAssuredConfigurationCustomizer
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.restdocs.restassured.RestAssuredRestDocumentationConfigurer
import org.springframework.restdocs.templates.TemplateFormats
@TestConfiguration(proxyBeanMethods = false)
class MyRestDocsConfiguration : RestDocsRestAssuredConfigurationCustomizer {
override fun customize(configurer: RestAssuredRestDocumentationConfigurer) {
configurer.snippets().withTemplateFormat(TemplateFormats.markdown())
}
}自动配置的 Spring Web Services 测试
自动配置的 Spring Web Services 客户端测试
您可以使用 @WebServiceClientTest 来测试使用 Spring Web Services 项目调用 Web 服务的应用。默认情况下，它配置一个 MockWebServiceServer bean 并自动定制您的 WebServiceTemplateBuilder。（更多关于在 Spring Boot 中使用 Web Services 的信息，请参见Web Services。）
由 @WebServiceClientTest 启用的自动配置设置列表在附录中可以找到。 |
以下示例展示了 @WebServiceClientTest 注解的使用方法
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.webservices.client.WebServiceClientTest;
import org.springframework.ws.test.client.MockWebServiceServer;
import org.springframework.xml.transform.StringSource;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.ws.test.client.RequestMatchers.payload;
import static org.springframework.ws.test.client.ResponseCreators.withPayload;
@WebServiceClientTest(SomeWebService.class)
class MyWebServiceClientTests {
@Autowired
private MockWebServiceServer server;
@Autowired
private SomeWebService someWebService;
@Test
void mockServerCall() {
this.server
.expect(payload(new StringSource("<request/>")))
.andRespond(withPayload(new StringSource("<response><status>200</status></response>")));
assertThat(this.someWebService.test())
.extracting(Response::getStatus)
.isEqualTo(200);
}
}import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.webservices.client.WebServiceClientTest
import org.springframework.ws.test.client.MockWebServiceServer
import org.springframework.ws.test.client.RequestMatchers
import org.springframework.ws.test.client.ResponseCreators
import org.springframework.xml.transform.StringSource
@WebServiceClientTest(SomeWebService::class)
class MyWebServiceClientTests(@Autowired val server: MockWebServiceServer, @Autowired val someWebService: SomeWebService) {
@Test
fun mockServerCall() {
server
.expect(RequestMatchers.payload(StringSource("<request/>")))
.andRespond(ResponseCreators.withPayload(StringSource("<response><status>200</status></response>")))
assertThat(this.someWebService.test()).extracting(Response::status).isEqualTo(200)
}
}自动配置的 Spring Web Services 服务器测试
您可以使用 @WebServiceServerTest 来测试使用 Spring Web Services 项目实现 Web 服务的应用。默认情况下，它配置一个 MockWebServiceClient bean，可用于调用您的 Web 服务端点。（更多关于在 Spring Boot 中使用 Web Services 的信息，请参见Web Services。）
由 @WebServiceServerTest 启用的自动配置设置列表在附录中可以找到。 |
以下示例展示了 @WebServiceServerTest 注解的使用方法
-
Java
-
Kotlin
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.webservices.server.WebServiceServerTest;
import org.springframework.ws.test.server.MockWebServiceClient;
import org.springframework.ws.test.server.RequestCreators;
import org.springframework.ws.test.server.ResponseMatchers;
import org.springframework.xml.transform.StringSource;
@WebServiceServerTest(ExampleEndpoint.class)
class MyWebServiceServerTests {
@Autowired
private MockWebServiceClient client;
@Test
void mockServerCall() {
this.client
.sendRequest(RequestCreators.withPayload(new StringSource("<ExampleRequest/>")))
.andExpect(ResponseMatchers.payload(new StringSource("<ExampleResponse>42</ExampleResponse>")));
}
}import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.webservices.server.WebServiceServerTest
import org.springframework.ws.test.server.MockWebServiceClient
import org.springframework.ws.test.server.RequestCreators
import org.springframework.ws.test.server.ResponseMatchers
import org.springframework.xml.transform.StringSource
@WebServiceServerTest(ExampleEndpoint::class)
class MyWebServiceServerTests(@Autowired val client: MockWebServiceClient) {
@Test
fun mockServerCall() {
client
.sendRequest(RequestCreators.withPayload(StringSource("<ExampleRequest/>")))
.andExpect(ResponseMatchers.payload(StringSource("<ExampleResponse>42</ExampleResponse>")))
}
}额外的自动配置和切片
每个切片提供一个或多个 @AutoConfigure… 注解，它们主要定义了应包含在切片中的自动配置。可以通过创建自定义的 @AutoConfigure… 注解或通过将 @ImportAutoConfiguration 添加到测试中来逐个测试地添加额外的自动配置，如下例所示
-
Java
-
Kotlin
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration;
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest;
@JdbcTest
@ImportAutoConfiguration(IntegrationAutoConfiguration.class)
class MyJdbcTests {
}import org.springframework.boot.autoconfigure.ImportAutoConfiguration
import org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration
import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest
@JdbcTest
@ImportAutoConfiguration(IntegrationAutoConfiguration::class)
class MyJdbcTests请确保不要使用常规的 @Import 注解导入自动配置，因为 Spring Boot 以特定方式处理它们。 |
或者，可以通过在存储在 META-INF/spring 中的文件中注册它们，为任何使用切片注解的地方添加额外的自动配置，如下例所示
com.example.IntegrationAutoConfiguration在此示例中，对于每个使用 @JdbcTest 注解的测试，都启用了 com.example.IntegrationAutoConfiguration。
您可以在此文件中使用以 # 开头的注释。 |
只要切片或 @AutoConfigure… 注解元注解了 @ImportAutoConfiguration，就可以通过这种方式进行定制。 |
用户配置和切片
如果组织您的代码的方式合理，您的 @SpringBootApplication 类默认被用作测试的配置。
因此，不要在应用的主类中散布特定于其某个功能领域的配置设置变得很重要。
假设您正在使用 Spring Data MongoDB，依赖于其自动配置，并且已启用审计。您可以如下定义您的 @SpringBootApplication
-
Java
-
Kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.mongodb.config.EnableMongoAuditing;
@SpringBootApplication
@EnableMongoAuditing
public class MyApplication {
// ...
}import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.data.mongodb.config.EnableMongoAuditing
@SpringBootApplication
@EnableMongoAuditing
class MyApplication {
// ...
}因为此类是测试的源配置，所以任何切片测试实际上都会尝试启用 Mongo 审计，这肯定不是您想要做的。建议的方法是将该领域特定的配置移到一个单独的 @Configuration 类中，该类与您的应用处于同一级别，如下例所示
-
Java
-
Kotlin
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.EnableMongoAuditing;
@Configuration(proxyBeanMethods = false)
@EnableMongoAuditing
public class MyMongoConfiguration {
// ...
}import org.springframework.context.annotation.Configuration
import org.springframework.data.mongodb.config.EnableMongoAuditing
@Configuration(proxyBeanMethods = false)
@EnableMongoAuditing
class MyMongoConfiguration {
// ...
}根据应用程序的复杂性，您可以选择使用一个单独的 @Configuration 类来包含所有自定义配置，或者按领域划分，每个领域一个类。后一种方法允许您在需要时通过 @Import 注解在某个测试中启用特定配置。有关何时可能需要为 slice test 启用特定 @Configuration 类的更多详细信息，请参阅 本 how-to 部分。 |
Slice test 会从扫描中排除 @Configuration 类。例如，对于 @WebMvcTest，以下配置不会将给定的 WebMvcConfigurer bean 包含在 slice test 加载的应用程序上下文中
-
Java
-
Kotlin
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration(proxyBeanMethods = false)
public class MyWebConfiguration {
@Bean
public WebMvcConfigurer testConfigurer() {
return new WebMvcConfigurer() {
// ...
};
}
}import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
@Configuration(proxyBeanMethods = false)
class MyWebConfiguration {
@Bean
fun testConfigurer(): WebMvcConfigurer {
return object : WebMvcConfigurer {
// ...
}
}
}然而，下面的配置将使自定义的 WebMvcConfigurer 由 slice test 加载。
-
Java
-
Kotlin
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {
// ...
}import org.springframework.stereotype.Component
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
@Component
class MyWebMvcConfigurer : WebMvcConfigurer {
// ...
}另一个容易混淆的地方是 classpath 扫描。假设您以合理的方式组织了代码，但需要扫描额外的包。您的应用程序可能类似于以下代码
-
Java
-
Kotlin
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
@ComponentScan({ "com.example.app", "com.example.another" })
public class MyApplication {
// ...
}import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.context.annotation.ComponentScan
@SpringBootApplication
@ComponentScan("com.example.app", "com.example.another")
class MyApplication {
// ...
}这样做实际上覆盖了默认的组件扫描指令，副作用是无论您选择哪种 slice，都会扫描这两个包。例如，@DataJpaTest 似乎突然扫描了应用程序的组件和用户配置。同样，将自定义指令移到一个单独的类中是解决此问题的好方法。
如果这不适用于您，您可以在测试层次结构中的某个地方创建一个 @SpringBootConfiguration，以便它被替代使用。或者，您可以为测试指定一个源，这会禁用查找默认源的行为。 |
使用 Spock 测试 Spring Boot 应用程序
Spock 2.2 或更高版本可用于测试 Spring Boot 应用程序。为此，请在应用程序的构建中添加 Spock 的 spock-spring 模块的 -groovy-4.0 版本依赖。spock-spring 将 Spring 的测试框架集成到 Spock 中。有关更多详细信息，请参阅 Spock Spring 模块的文档。
