跳到主要内容

测试 Spring Boot 应用程序

DeepSeek V3 中英对照 Testing Spring Boot Applications

Spring Boot 应用程序是一个 Spring ApplicationContext，因此除了通常对普通 Spring 上下文所做的操作之外，不需要做任何特别的事情来测试它。

备注

默认情况下，只有在使用 SpringApplication 创建上下文时，Spring Boot 的外部属性、日志记录和其他功能才会被安装到上下文中。

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（默认）：加载一个 Web ApplicationContext 并提供模拟的 Web 环境。使用此注解时不会启动嵌入式服务器。如果类路径中没有可用的 Web 环境，此模式会透明地回退到创建常规的非 Web ApplicationContext。它可以与 @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 属性：

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(properties = "spring.main.web-application-type=reactive")
class MyWebFluxTests {

    // ...

}
java

检测测试配置​

如果你熟悉 Spring 测试框架，你可能习惯于使用 @ContextConfiguration(classes=…​) 来指定要加载的 Spring @Configuration。或者，你可能经常在测试中使用嵌套的 @Configuration 类。

在测试 Spring Boot 应用时，通常不需要显式指定配置。Spring Boot 的 @*Test 注解会在你没有显式定义配置时自动搜索主配置。

搜索算法从包含测试的包开始向上查找，直到找到带有 @SpringBootApplication 或 @SpringBootConfiguration 注解的类。只要您以合理的方式组织代码，通常都能找到主配置。

备注

如果你使用 测试注解来测试应用程序的某个更具体的部分，你应该避免在 主方法的应用程序类 上添加特定于某个区域的配置设置。

@SpringBootApplication 的底层组件扫描配置定义了排除过滤器，以确保切片按预期工作。如果你在 @SpringBootApplication 注解的类上使用了显式的 @ComponentScan 指令，请注意这些过滤器将被禁用。如果你使用了切片，你应该重新定义它们。

如果你想自定义主配置，可以使用嵌套的 @TestConfiguration 类。与嵌套的 @Configuration 类不同，后者会替代应用程序的主配置，而嵌套的 @TestConfiguration 类是在应用程序主配置的基础上额外使用的。

备注

Spring 的测试框架会在测试之间缓存应用程序上下文。因此，只要你的测试共享相同的配置（无论它是如何被发现的），加载上下文的潜在耗时过程只会发生一次。

使用测试配置的主方法​

通常，@SpringBootTest 发现的测试配置将是你的主 @SpringBootApplication。在大多数结构良好的应用程序中，这个配置类还会包含用于启动应用程序的 main 方法。

例如，以下是一个典型的 Spring Boot 应用程序中非常常见的代码模式：

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

}
java

在上面的示例中，main 方法除了委托给 SpringApplication.run(Class, String…​) 之外，没有做其他事情。然而，也可以编写一个更复杂的 main 方法，在调用 SpringApplication.run(Class, String…​) 之前应用自定义配置。

例如，这里有一个应用程序可以更改横幅模式并设置附加配置文件：

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

}
java

由于在 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 方法设置了额外的配置文件，那么这些配置文件将在 ApplicationContext 启动时生效。

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() {
        // ...
    }

}
java

排除测试配置​

如果你的应用程序使用了组件扫描（例如，如果你使用了 @SpringBootApplication 或 @ComponentScan），你可能会发现仅为特定测试创建的最高层配置类意外地在所有地方都被扫描到了。

正如我们之前所见，@TestConfiguration 可以用于测试的内部类，以自定义主配置。@TestConfiguration 也可以用于顶层类。这样做表示该类不应通过扫描被自动加载。然后你可以在需要的地方显式导入该类，如下例所示：

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() {
        // ...
    }

}
java
备注

如果你直接使用 @ComponentScan（即不通过 @SpringBootApplication），你需要注册 TypeExcludeFilter。详情请参阅 TypeExcludeFilter API 文档。

备注

导入的 @TestConfiguration 会比内部类的 @TestConfiguration 更早被处理，并且导入的 @TestConfiguration 会在通过组件扫描找到的任何配置之前被处理。一般来说，这种顺序上的差异不会产生明显的影响，但如果你依赖于 Bean 的覆盖，这一点是需要注意的。

使用应用程序参数​

如果你的应用程序期望接收参数，你可以通过 @SpringBootTest 的 args 属性来注入这些参数。

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

}
java

使用模拟环境进行测试​

默认情况下，@SpringBootTest 不会启动服务器，而是会设置一个用于测试 Web 端点的模拟环境。

使用 Spring MVC，我们可以通过 MockMvc 来查询我们的 Web 端点。提供了三种集成方式：

以下示例展示了可用的集成：

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

}
java
提示

如果你只想关注 Web 层，而不想启动完整的 ApplicationContext，可以考虑 使用 @WebMvcTest。

在使用 Spring WebFlux 端点时，你可以使用 WebTestClient，如下例所示：

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

}
java
提示

在模拟环境中进行测试通常比使用完整的 Servlet 容器运行要快。然而，由于模拟发生在 Spring MVC 层，因此依赖于底层 Servlet 容器行为的代码无法直接使用 MockMvc 进行测试。

例如，Spring Boot 的错误处理基于 Servlet 容器提供的“错误页面”支持。这意味着，虽然你可以测试你的 MVC 层是否按预期抛出和处理异常，但无法直接测试是否渲染了特定的自定义错误页面。如果你需要测试这些底层逻辑，可以按照下一节中的描述启动一个完全运行的服务器。

使用运行中的服务器进行测试​

如果你需要启动一个完整的运行中的服务器，我们建议你使用随机端口。如果你使用 @SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)，每次运行测试时都会随机选择一个可用的端口。

@LocalServerPort 注解可用于将实际使用的端口注入到你的测试中。为了方便起见，需要向已启动的服务器发起 REST 调用的测试还可以自动装配一个 WebTestClient，它可以将相对链接解析为正在运行的服务器，并附带一个专用的 API 用于验证响应，如下例所示：

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

}
java
提示

WebTestClient 也可以与 模拟环境 一起使用，通过在你的测试类上添加 @AutoConfigureWebTestClient 注解，从而无需启动服务器。

此设置要求在类路径中包含 spring-webflux。如果您不能或不想添加 webflux，Spring Boot 还提供了一个 TestRestTemplate 工具：

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

}
java

自定义 WebTestClient​

要自定义 WebTestClient bean，可以配置一个 WebTestClientBuilderCustomizer bean。任何这样的 bean 都会被调用，并传入用于创建 WebTestClient 的 WebTestClient.Builder。

使用 JMX​

由于测试上下文框架会缓存上下文，默认情况下 JMX 被禁用，以防止相同的组件在相同的域上注册。如果此类测试需要访问 MBeanServer，请考虑将其标记为脏状态：

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");
        // ...
    }

}
java

使用观测​

如果你使用 @AutoConfigureObservability 注解一个 切片测试，它将自动配置一个 ObservationRegistry。

使用指标​

无论你的类路径如何，除了基于内存的注册表外，在使用 @SpringBootTest 时，其他类型的 Meter 注册表都不会自动配置。

如果你需要将指标导出到不同的后端作为集成测试的一部分，可以使用 @AutoConfigureObservability 注解来配置。

如果你使用 @AutoConfigureObservability 注解来标注切片测试，它会自动配置一个内存中的 MeterRegistry。在切片测试中，使用 @AutoConfigureObservability 注解时不支持数据导出。

使用追踪​

无论你的类路径如何，在使用 @SpringBootTest 时，报告数据的追踪组件都不会自动配置。

如果你需要将这些组件作为集成测试的一部分，请使用 @AutoConfigureObservability 注解来标注测试。

如果你已经创建了自己的报告组件（例如自定义的 SpanExporter 或 brave.handler.SpanHandler）并且你不希望它们在测试中生效，你可以使用 @ConditionalOnEnabledTracing 注解来禁用它们。

如果你使用 @AutoConfigureObservability 注解来标注 一个切片测试，它会自动配置一个无操作的 Tracer。在切片测试中，不支持使用 @AutoConfigureObservability 注解来导出数据。

模拟和监视 Beans​

在运行测试时，有时需要模拟应用程序上下文中的某些组件。例如，你可能有一个封装了某些远程服务的外观（facade），而这些服务在开发期间不可用。模拟功能在你想模拟那些在真实环境中难以触发的故障时也非常有用。

Spring Framework 包含一个 @MockitoBean 注解，可用于在你的 ApplicationContext 中为 bean 定义一个 Mockito 模拟对象。此外，@MockitoSpyBean 可用于定义一个 Mockito 间谍对象。你可以在 Spring Framework 文档 中了解更多关于这些功能的信息。

自动配置测试​

Spring Boot 的自动配置系统在应用中运行良好，但有时对测试来说可能有些过于复杂。通常，只加载测试应用“切片”所需的配置部分会有所帮助。例如，你可能希望测试 Spring MVC 控制器是否正确映射了 URL，并且不希望在这些测试中涉及数据库调用；或者你可能希望测试 JPA 实体，而在这些测试运行时对 Web 层不感兴趣。

spring-boot-test-autoconfigure 模块包含了一系列注解，这些注解可用于自动配置这些“切片”。每个注解的工作方式类似，提供一个 @…​Test 注解来加载 ApplicationContext，以及一个或多个 @AutoConfigure…​ 注解，用于自定义自动配置设置。

备注

每个切片将组件扫描限制为适当的组件，并加载一组非常受限的自动配置类。如果你需要排除其中的某些配置，大多数 @…​Test 注解提供了 excludeAutoConfiguration 属性。或者，你也可以使用 @ImportAutoConfiguration#exclude。

备注

不支持在一个测试中使用多个 @…​Test 注解来包含多个“切片”。如果你需要多个“切片”，请选择其中一个 @…​Test 注解，并手动包含其他“切片”的 @AutoConfigure…​ 注解。

提示

也可以将 @AutoConfigure…​ 注解与标准的 @SpringBootTest 注解一起使用。如果你不希望对应用程序进行“切片”，但希望使用一些自动配置的测试 bean，可以使用这种组合。

自动配置的 JSON 测试​

为了测试对象的 JSON 序列化和反序列化是否按预期工作，你可以使用 @JsonTest 注解。@JsonTest 会自动配置支持的 JSON 映射器，它可以是以下库之一：

提示

@JsonTest 启用的自动配置列表可以在附录中找到。

如果你需要配置自动配置的元素，可以使用 @AutoConfigureJsonTesters 注解。

Spring Boot 包含了基于 AssertJ 的辅助工具，这些工具与 JSONAssert 和 JsonPath 库一起使用，用于检查 JSON 是否符合预期。JacksonTester、GsonTester、JsonbTester 和 BasicJsonTester 类分别用于 Jackson、Gson、Jsonb 和字符串。在使用 @JsonTest 时，测试类中的任何辅助字段都可以通过 @Autowired 进行注入。以下示例展示了用于 Jackson 的测试类：

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

}
java
备注

JSON 辅助类也可以直接在标准单元测试中使用。为此，如果你不使用 @JsonTest 注解，可以在你的 @BeforeEach 方法中调用辅助类的 initFields 方法。

如果你使用 Spring Boot 基于 AssertJ 的辅助工具来断言给定 JSON 路径下的数值，根据类型的不同，可能无法使用 isEqualTo。相反，你可以使用 AssertJ 的 satisfies 来断言该值符合给定的条件。例如，以下示例断言实际数值是一个接近 0.15 的浮点数，误差范围为 0.01。

@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)));
    }
java

自动配置的 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 启用的自动配置设置列表可以在附录中找到。

提示

如果你需要注册额外的组件，比如 Jackson 的 Module，你可以通过在测试类上使用 @Import 来导入额外的配置类。

通常，@WebMvcTest 仅限于单个控制器，并与 @MockBean 结合使用，以为所需的协作者提供模拟实现。

@WebMvcTest 还会自动配置 MockMvc。Mock MVC 提供了一种强大的方式，可以快速测试 MVC 控制器，而无需启动完整的 HTTP 服务器。如果 AssertJ 可用，MockMvcTester 提供的 AssertJ 支持也会被自动配置。

提示

你也可以在非 @WebMvcTest（例如 @SpringBootTest）中通过使用 @AutoConfigureMockMvc 注解来自动配置 MockMvc 和 MockMvcTester。以下示例使用了 MockMvcTester：

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

}
java
提示

如果你需要配置自动配置的元素（例如，当 Servlet 过滤器应该被应用时），你可以使用 @AutoConfigureMockMvc 注解中的属性。

如果你使用 HtmlUnit 和 Selenium，自动配置还会提供一个 HtmlUnit WebClient bean 和/或一个 Selenium WebDriver bean。以下示例使用了 HtmlUnit：

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

}
java
备注

默认情况下，Spring Boot 将 WebDriver bean 放在一个特殊的“作用域”中，以确保驱动程序在每个测试后退出，并注入一个新的实例。如果你不希望这种行为，可以在 WebDriver 的 @Bean 定义中添加 @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)。

注意

Spring Boot 创建的 webDriver 作用域将替换任何用户定义的相同名称的作用域。如果你定义了自己的 webDriver 作用域，在使用 @WebMvcTest 时，你可能会发现它停止工作。

如果你的类路径上有 Spring Security，@WebMvcTest 也会扫描 WebSecurityConfigurer bean。对于此类测试，与其完全禁用安全功能，你可以使用 Spring Security 的测试支持。关于如何使用 Spring Security 的 MockMvc 支持的更多详细信息，可以在 使用 Spring Security 进行测试 的“操作指南”部分找到。

提示

有时候仅仅编写 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 启用的自动配置列表可以在附录中找到。

提示

如果你需要注册额外的组件，例如 Jackson Module，你可以在测试中使用 @Import 导入额外的配置类。

通常情况下，@WebFluxTest 仅限于单个控制器，并与 @MockBean 注解结合使用，以提供所需协作者的模拟实现。

@WebFluxTest 还会自动配置 WebTestClient，它提供了一种强大的方式，可以快速测试 WebFlux 控制器，而无需启动完整的 HTTP 服务器。

提示

你也可以在非 @WebFluxTest（例如 @SpringBootTest）中通过使用 @AutoConfigureWebTestClient 注解来自动配置 WebTestClient。以下示例展示了一个同时使用 @WebFluxTest 和 WebTestClient 的类：

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

}
java
提示

此设置仅由 WebFlux 应用程序支持，因为目前仅在 WebFlux 中可以在模拟的 Web 应用程序中使用 WebTestClient。

备注

@WebFluxTest 无法检测通过函数式 Web 框架注册的路由。为了测试上下文中的 RouterFunction bean，考虑通过使用 @Import 或者使用 @SpringBootTest 来手动导入你的 RouterFunction。

备注

@WebFluxTest 无法检测到作为 @Bean 注册的自定义安全配置，类型为 SecurityWebFilterChain。要在测试中包含该配置，您需要通过使用 @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>
xml
dependencies {
    testImplementation("org.springframework.graphql:spring-graphql-test")
    // Unless already present in the implementation configuration
    testImplementation("org.springframework.boot:spring-boot-starter-webflux")
}
gradle

这个测试模块提供了 GraphQlTester。该测试器在测试中被广泛使用，因此请务必熟悉它的使用。根据测试类型的不同，Spring Boot 会自动配置不同的 GraphQlTester 变体：

Spring Boot 帮助你使用 @GraphQlTest 注解来测试 Spring GraphQL 控制器。@GraphQlTest 会自动配置 Spring GraphQL 基础设施，而不涉及任何传输或服务器。这将扫描的 Bean 限制为 @Controller、RuntimeWiringConfigurer、JsonComponent、Converter、GenericConverter、DataFetcherExceptionResolver、Instrumentation 和 GraphQlSourceBuilderCustomizer。在使用 @GraphQlTest 注解时，常规的 @Component 和 @ConfigurationProperties Bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties Bean。

提示

由 @GraphQlTest 启用的自动配置列表可以在附录中找到。

通常情况下，@GraphQlTest 仅限于一组控制器，并与 @MockBean 注解结合使用，以便为所需的协作者提供模拟实现。

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!");
    }

}
java

@SpringBootTest 测试是完整的集成测试，涉及整个应用程序。当使用随机或定义的端口时，会配置一个实时服务器，并且会自动提供一个 HttpGraphQlTester bean，以便您可以使用它来测试服务器。当配置为 MOCK 环境时，您还可以通过在测试类上使用 @AutoConfigureHttpGraphQlTester 注解来请求一个 HttpGraphQlTester bean：

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!");
    }

}
java

自动配置的 Data Cassandra 测试​

你可以使用 @DataCassandraTest 来测试 Cassandra 应用程序。默认情况下，它会配置一个 CassandraTemplate，扫描 @Table 类，并配置 Spring Data Cassandra 仓库。当使用 @DataCassandraTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Cassandra 的更多信息，请参阅 Cassandra。）

提示

由 @DataCassandraTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了在 Spring Boot 中使用 Cassandra 测试的典型设置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.cassandra.DataCassandraTest;

@DataCassandraTest
class MyDataCassandraTests {

    @Autowired
    private SomeRepository repository;

}
java

自动配置的 Couchbase 数据测试​

你可以使用 @DataCouchbaseTest 来测试 Couchbase 应用程序。默认情况下，它会配置一个 CouchbaseTemplate 或 ReactiveCouchbaseTemplate，扫描 @Document 类，并配置 Spring Data Couchbase 仓库。当使用 @DataCouchbaseTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。@EnableConfigurationProperties 可用于包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Couchbase 的更多信息，请参阅本章前面的 Couchbase。）

提示

由 @DataCouchbaseTest 启用的自动配置设置列表可以在附录中查看。

以下示例展示了在 Spring Boot 中使用 Couchbase 测试的典型配置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.couchbase.DataCouchbaseTest;

@DataCouchbaseTest
class MyDataCouchbaseTests {

    @Autowired
    private SomeRepository repository;

    // ...

}
java

自动配置的 Elasticsearch 数据测试​

你可以使用 @DataElasticsearchTest 来测试 Elasticsearch 应用程序。默认情况下，它会配置一个 ElasticsearchTemplate，扫描 @Document 类，并配置 Spring Data Elasticsearch 仓库。在使用 @DataElasticsearchTest 注解时，常规的 @Component 和 @ConfigurationProperties Bean 不会被扫描。你可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties Bean。（有关在 Spring Boot 中使用 Elasticsearch 的更多信息，请参阅本章前面的 Elasticsearch 部分。）

提示

由 @DataElasticsearchTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了在 Spring Boot 中使用 Elasticsearch 测试的典型设置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.elasticsearch.DataElasticsearchTest;

@DataElasticsearchTest
class MyDataElasticsearchTests {

    @Autowired
    private SomeRepository repository;

    // ...

}
java

自动配置的 Data JPA 测试​

你可以使用 @DataJpaTest 注解来测试 JPA 应用程序。默认情况下，它会扫描 @Entity 类并配置 Spring Data JPA 仓库。如果类路径上有一个嵌入式数据库可用，它也会配置一个。默认情况下，通过将 spring.jpa.show-sql 属性设置为 true 来记录 SQL 查询。你可以使用注解的 showSql 属性来禁用此功能。

使用 @DataJpaTest 注解时，常规的 @Component 和 @ConfigurationProperties Bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties Bean。

提示

@DataJpaTest 启用的自动配置设置列表可以在附录中找到。

默认情况下，数据 JPA 测试是事务性的，并在每个测试结束时回滚。有关更多详细信息，请参阅 Spring 框架参考文档 中的相关部分。如果这不是你想要的，你可以按照以下方式为测试或整个类禁用事务管理：

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 {

    // ...

}
java

Data JPA 测试也可以注入一个 TestEntityManager bean，它提供了一种替代标准 JPA EntityManager 的方式，专门为测试设计。

提示

TestEntityManager 也可以通过添加 @AutoConfigureTestEntityManager 自动配置到任何基于 Spring 的测试类中。在这样做时，请确保您的测试在事务中运行，例如通过在测试类或方法上添加 @Transactional。

如果你需要，也可以使用 JdbcTemplate。以下示例展示了如何使用 @DataJpaTest 注解：

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

}
java

内存嵌入式数据库通常在测试中表现良好，因为它们速度快且无需任何安装。然而，如果您更倾向于针对真实数据库运行测试，可以使用 @AutoConfigureTestDatabase 注解，如下例所示：

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 {

    // ...

}
java

自动配置的 JDBC 测试​

@JdbcTest 类似于 @DataJpaTest，但它是针对仅需要 DataSource 并且不使用 Spring Data JDBC 的测试。默认情况下，它会配置一个内存中的嵌入式数据库和一个 JdbcTemplate。当使用 @JdbcTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties bean。

提示

@JdbcTest 启用的自动配置列表可以在附录中找到。

默认情况下，JDBC 测试是事务性的，并在每个测试结束时回滚。有关更多详细信息，请参阅 Spring 框架参考文档 中的相关部分。如果这不是你想要的，你可以为单个测试或整个类禁用事务管理，如下所示：

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 {

}
java

如果你更倾向于让测试在真实的数据库上运行，你可以使用 @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 相同。（参见 Auto-configured Data JPA Tests）。

自动配置的 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 测试​

你可以使用 @JooqTest 的方式与使用 @JdbcTest 类似，但用于与 jOOQ 相关的测试。由于 jOOQ 严重依赖与数据库模式相对应的基于 Java 的模式，因此使用了现有的 DataSource。如果你想用一个内存数据库替换它，可以使用 @AutoConfigureTestDatabase 来覆盖这些设置。（有关在 Spring Boot 中使用 jOOQ 的更多信息，请参阅 使用 jOOQ。）在使用 @JooqTest 注解时，常规的 @Component 和 @ConfigurationProperties Bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties Bean。

提示

@JooqTest 启用的自动配置列表可以在附录中找到。

@JooqTest 配置了一个 DSLContext。以下示例展示了如何使用 @JooqTest 注解：

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;

    // ...

}
java

JOOQ 测试默认是事务性的，并且在每个测试结束时自动回滚。如果不希望如此，你可以为某个测试或整个测试类禁用事务管理，如 JDBC 示例 所示。

自动配置的 MongoDB 数据测试​

你可以使用 @DataMongoTest 来测试 MongoDB 应用程序。默认情况下，它会配置一个 MongoTemplate，扫描 @Document 类，并配置 Spring Data MongoDB 仓库。当使用 @DataMongoTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。@EnableConfigurationProperties 可以用来包含 @ConfigurationProperties bean。（有关如何在 Spring Boot 中使用 MongoDB 的更多信息，请参阅 MongoDB。）

提示

由 @DataMongoTest 启用的自动配置设置列表可以在附录中找到。

以下类展示了 @DataMongoTest 注解的使用：

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;

    // ...

}
java

自动配置的 Data Neo4j 测试​

你可以使用 @DataNeo4jTest 来测试 Neo4j 应用程序。默认情况下，它会扫描 @Node 类，并配置 Spring Data Neo4j 仓库。当使用 @DataNeo4jTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 Neo4j 的更多信息，请参阅 Neo4j。）

提示

@DataNeo4jTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了在 Spring Boot 中使用 Neo4J 测试的典型设置：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.neo4j.DataNeo4jTest;

@DataNeo4jTest
class MyDataNeo4jTests {

    @Autowired
    private SomeRepository repository;

    // ...

}
java

默认情况下，Data Neo4j 测试是事务性的，并在每次测试结束时回滚。有关更多详细信息，请参阅 Spring Framework 参考文档中的相关章节。如果这不是你想要的行为，你可以为某个测试或整个类禁用事务管理，如下所示：

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 {

}
java
备注

响应式访问不支持事务性测试。如果您使用这种风格，必须按照上述方式配置 @DataNeo4jTest 测试。

自动配置的数据 Redis 测试​

你可以使用 @DataRedisTest 来测试 Redis 应用程序。默认情况下，它会扫描 @RedisHash 类并配置 Spring Data Redis 存储库。当使用 @DataRedisTest 注解时，常规的 @Component 和 @ConfigurationProperties Bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties Bean。（有关在 Spring Boot 中使用 Redis 的更多信息，请参阅 Redis。）

提示

@DataRedisTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了 @DataRedisTest 注解的使用：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.data.redis.DataRedisTest;

@DataRedisTest
class MyDataRedisTests {

    @Autowired
    private SomeRepository repository;

    // ...

}
java

自动配置的 Data LDAP 测试​

你可以使用 @DataLdapTest 来测试 LDAP 应用程序。默认情况下，它会配置一个内存中的嵌入式 LDAP（如果可用），配置一个 LdapTemplate，扫描 @Entry 类，并配置 Spring Data LDAP 仓库。当使用 @DataLdapTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties bean。（有关在 Spring Boot 中使用 LDAP 的更多信息，请参阅 LDAP。）

提示

由 @DataLdapTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了 @DataLdapTest 注解的使用：

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;

    // ...

}
java

内存嵌入式 LDAP 通常在测试中表现良好，因为它速度快且不需要开发者进行任何安装。然而，如果您更倾向于针对真实的 LDAP 服务器运行测试，则应排除嵌入式 LDAP 的自动配置，如下例所示：

import org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.ldap.DataLdapTest;

@DataLdapTest(excludeAutoConfiguration = EmbeddedLdapAutoConfiguration.class)
class MyDataLdapTests {

    // ...

}
java

自动配置的 REST 客户端​

你可以使用 @RestClientTest 注解来测试 REST 客户端。默认情况下，它会自动配置 Jackson、GSON 和 Jsonb 支持，配置一个 RestTemplateBuilder 和一个 RestClient.Builder，并添加对 MockRestServiceServer 的支持。当使用 @RestClientTest 注解时，常规的 @Component 和 @ConfigurationProperties bean 不会被扫描。你可以使用 @EnableConfigurationProperties 来包含 @ConfigurationProperties bean。

提示

@RestClientTest 启用的自动配置设置列表可以在 附录 中找到。

你希望通过 value 或 components 属性来指定想要测试的具体 bean，这些属性属于 @RestClientTest 注解。

当在被测的 bean 中使用 RestTemplateBuilder 并且在构建 RestTemplate 时调用了 RestTemplateBuilder.rootUri(String rootUri)，那么在 MockRestServiceServer 的期望中应该省略根 URI，如下例所示：

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

}
java

在使用被测 Bean 中的 RestClient.Builder 时，或者在使用 RestTemplateBuilder 但未调用 rootUri(String rootURI) 时，必须在 MockRestServiceServer 的期望中使用完整的 URI，如下例所示：

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

}
java

自动配置的 Spring REST Docs 测试​

你可以使用 @AutoConfigureRestDocs 注解，在测试中使用 Mock MVC、REST Assured 或 WebTestClient 来集成 Spring REST Docs。它消除了在 Spring REST Docs 中使用 JUnit 扩展的需求。

@AutoConfigureRestDocs 可用于覆盖默认的输出目录（如果使用 Maven，则为 target/generated-snippets；如果使用 Gradle，则为 build/generated-snippets）。它还可以用于配置出现在任何文档化 URI 中的主机、方案和端口。

使用 Mock MVC 自动配置的 Spring REST Docs 测试​

@AutoConfigureRestDocs 用于在测试基于 servlet 的 Web 应用程序时，配置 MockMvc bean 以使用 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"));
    }

}
java

如果您更倾向于使用 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"));
    }

}
java

两者在背后都使用了同一个 MockMvc 实例，因此对其进行的任何配置都会同时应用到两者。

如果你需要对 Spring REST Docs 的配置进行比 @AutoConfigureRestDocs 提供的属性更细粒度的控制，你可以使用一个 RestDocsMockMvcConfigurationCustomizer 的 Bean，如下例所示：

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

}
java

如果你想利用 Spring REST Docs 对参数化输出目录的支持，你可以创建一个 RestDocumentationResultHandler Bean。自动配置会使用此结果处理器调用 alwaysDo，从而使每个 MockMvc 调用自动生成默认的代码片段。以下示例展示了如何定义一个 RestDocumentationResultHandler:

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

}
java

使用 WebTestClient 自动配置的 Spring REST Docs 测试​

@AutoConfigureRestDocs 也可以在测试响应式 Web 应用时与 WebTestClient 一起使用。你可以通过 @Autowired 注入它，并在测试中像通常使用 @WebFluxTest 和 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.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"));
    }

}
java

如果你需要对 Spring REST Docs 的配置进行比 @AutoConfigureRestDocs 属性提供的更多控制，你可以使用 RestDocsWebTestClientConfigurationCustomizer bean，如下例所示：

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

}
java

如果你想利用 Spring REST Docs 对参数化输出目录的支持，可以使用 WebTestClientBuilderCustomizer 来为每个实体交换结果配置一个消费者。以下示例展示了如何定义这样一个 WebTestClientBuilderCustomizer：

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

}
java

使用 REST Assured 自动配置的 Spring REST Docs 测试​

@AutoConfigureRestDocs 会创建一个 RequestSpecification Bean，并预先配置为使用 Spring REST Docs，使其在你的测试中可用。你可以通过 @Autowired 注入它，并在测试中像往常一样使用它，就像使用 REST Assured 和 Spring REST Docs 时一样，如下例所示：

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

}
java

如果你需要对 Spring REST Docs 的配置进行比 @AutoConfigureRestDocs 属性提供的更多的控制，可以使用一个 RestDocsRestAssuredConfigurationCustomizer Bean，如下例所示：

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

}
java

自动配置的 Spring Web 服务测试​

自动配置的 Spring Web Services 客户端测试​

你可以使用 @WebServiceClientTest 来测试使用 Spring Web Services 项目调用 Web 服务的应用程序。默认情况下，它会配置一个 MockWebServiceServer bean，并自动自定义你的 WebServiceTemplateBuilder。（有关在 Spring Boot 中使用 Web 服务的更多信息，请参阅 Web Services。）

提示

由 @WebServiceClientTest 启用的自动配置设置列表可以在附录中找到。

以下示例展示了 @WebServiceClientTest 注解的使用：

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

}
java

自动配置的 Spring Web Services 服务器测试​

你可以使用 @WebServiceServerTest 来测试使用 Spring Web Services 项目实现的 Web 服务应用程序。默认情况下，它会配置一个 MockWebServiceClient bean，该 bean 可用于调用你的 Web 服务端点。（有关在 Spring Boot 中使用 Web 服务的更多信息，请参阅 Web 服务。）

提示

由 @WebServiceServerTest 启用的自动配置设置列表可以在 附录 中找到。

以下示例展示了 @WebServiceServerTest 注解的使用：

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

}
java

额外的自动配置和切片​

每个切片提供一个或多个 @AutoConfigure…​ 注解，这些注解定义了应作为切片一部分包含的自动配置。可以通过创建自定义 @AutoConfigure…​ 注解或在测试中添加 @ImportAutoConfiguration 来按需添加额外的自动配置，如下例所示：

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 {

}
java
备注

确保不要使用常规的 @Import 注解来导入自动配置，因为 Spring Boot 以特定的方式处理它们。

或者，对于任何使用切片注解的用途，可以通过在 META-INF/spring 目录中注册文件来添加额外的自动配置，如下例所示：

com.example.IntegrationAutoConfiguration
none

在这个示例中，com.example.IntegrationAutoConfiguration 在每个使用 @JdbcTest 注解的测试中被启用。

提示

你可以在这个文件中使用 # 添加注释。

提示

只要使用 @ImportAutoConfiguration 进行元注解，切片或 @AutoConfigure…​ 注解就可以通过这种方式进行自定义。

用户配置与切片​

如果你以合理的方式结构化你的代码，你的 @SpringBootApplication 类将默认用于测试配置。

因此，避免在应用程序的主类中混杂针对特定功能区域的配置设置变得尤为重要。

假设你正在使用 Spring Data MongoDB，并且依赖于它的自动配置，同时你已经启用了审计功能。你可以像下面这样定义你的 @SpringBootApplication：

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.mongodb.config.EnableMongoAuditing;

@SpringBootApplication
@EnableMongoAuditing
public class MyApplication {

    // ...

}
java

由于该类是测试的源配置，任何切片测试实际上都会尝试启用 MongoDB 审计，这显然不是你想要的结果。推荐的做法是将该特定区域的配置移至与应用程序同一层级的单独 @Configuration 类中，如下例所示：

import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.EnableMongoAuditing;

@Configuration(proxyBeanMethods = false)
@EnableMongoAuditing
public class MyMongoConfiguration {

    // ...

}
java
备注

根据应用程序的复杂性，您可能有一个用于自定义的 @Configuration 类，或者每个领域区域一个类。后一种方法允许您在必要时通过 @Import 注解在其中一个测试中启用它。有关何时可能希望为切片测试启用特定 @Configuration 类的更多详细信息，请参阅此操作指南部分。

测试切片会排除 @Configuration 类进行扫描。例如，对于 @WebMvcTest，以下配置将不会将给定的 WebMvcConfigurer bean 包含在测试切片加载的应用程序上下文中：

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() {
            // ...
        };
    }

}
java

然而，下面的配置会导致自定义的 WebMvcConfigurer 被测试切片加载。

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {

    // ...

}
java

另一个容易引起混淆的地方是类路径扫描。假设你已经以一种合理的方式组织了代码，但还需要扫描一个额外的包。你的应用程序可能类似于以下代码：

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
@ComponentScan({ "com.example.app", "com.example.another" })
public class MyApplication {

    // ...

}
java

这样做实际上会覆盖默认的组件扫描指令，并且无论你选择哪个切片，都会扫描这两个包。例如，一个 @DataJpaTest 似乎会突然扫描应用程序的组件和用户配置。再次强调，将自定义指令移动到单独的类中是解决此问题的好方法。

提示

如果这对你来说不可行，你可以在测试的层级结构中的某个位置创建一个 @SpringBootConfiguration，以便它被使用。或者，你可以为你的测试指定一个源，这将禁用查找默认源的行为。

使用 Spock 测试 Spring Boot 应用程序​

Spock 2.2 或更高版本可用于测试 Spring Boot 应用程序。为此，请在你的应用程序构建中添加对 Spock 的 spock-spring 模块的 -groovy-4.0 版本的依赖。spock-spring 将 Spring 的测试框架集成到 Spock 中。更多详细信息，请参阅 Spock Spring 模块的文档。