测试 Spring Boot 应用程序 (Testing Spring Boot Applications) _ Spring Boot3.3.2-SNAPSHOT中文文档(官方文档中文翻译)|Spring 教程 —

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.3.1！

Spring Boot 应用程序是 Spring ，因此除了通常使用普通 Spring 上下文执行的操作之外，不需要执行任何非常特别的操作来测试它。ApplicationContext

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

Spring Boot 提供了一个注解，当您需要 Spring Boot 功能时，它可以用作标准注解的替代。注解的工作原理是通过 SpringApplication 创建测试中使用的 ApplicationContext。除了许多其他注释之外，还提供了用于测试应用程序的更具体切片的注释。@SpringBootTestspring-test@ContextConfiguration@SpringBootTest

如果您使用的是 JUnit 4，请不要忘记也添加到您的测试中，否则注释将被忽略。如果您使用的是 JUnit 5，则无需添加等效的 as，并且其他注解已经用它进行了注释。@RunWith(SpringRunner.class)@ExtendWith(SpringExtension.class)@SpringBootTest@…Test

默认情况下，不会启动服务器。可以使用的属性进一步优化测试的运行方式：@SpringBootTestwebEnvironment@SpringBootTest

MOCK（默认）：加载 Web 并提供模拟 Web 环境。使用此注释时，嵌入式服务器不会启动。如果类路径上没有可用的 Web 环境，则此模式会透明地回退到创建常规非 Web 环境。它可以与 @AutoConfigureMockMvc 或 @AutoConfigureWebTestClient 结合使用，对 Web 应用程序进行基于模拟的测试。ApplicationContextApplicationContext
RANDOM_PORT：加载并提供真实的 Web 环境。嵌入式服务器启动并侦听随机端口。WebServerApplicationContext
DEFINED_PORT：加载并提供真实的 Web 环境。嵌入式服务器在定义的端口（从）或默认端口上侦听。WebServerApplicationContextapplication.properties8080
NONE：使用加载但不提供任何 Web 环境（模拟或其他）。ApplicationContextSpringApplication

默认情况下，如果测试为，则会在每个测试方法的末尾回滚事务。但是，由于将这种安排与 either 或隐式一起使用会提供真实的 servlet 环境，因此 HTTP 客户端和服务器在单独的线程中运行，因此在单独的事务中运行。在这种情况下，在服务器上启动的任何事务都不会回滚。@TransactionalRANDOM_PORTDEFINED_PORT

@SpringBootTest如果应用程序对管理服务器使用不同的端口，则 with 还将在单独的随机端口上启动管理服务器。webEnvironment = WebEnvironment.RANDOM_PORT

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

@SpringBootTest如果应用程序对管理服务器使用不同的端口，则 with 还将在单独的随机端口上启动管理服务器。webEnvironment = WebEnvironment.RANDOM_PORT

检测 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 {

	// ...

}

检测测试配置

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

在测试 Spring Boot 应用程序时，这通常不是必需的。 Spring Boot 的注解会在您未显式定义主配置时自动搜索主配置。@*Test

搜索算法从包含测试的包开始工作，直到找到用或批注的类。只要你以一种合理的方式构建你的代码，你的主要配置通常就会被找到。@SpringBootApplication@SpringBootConfiguration

如果使用测试批注来测试应用程序的更具体切片，则应避免在主方法的应用程序类上添加特定于特定区域的配置设置。

的基础组件扫描配置定义排除过滤器，这些过滤器用于确保切片按预期工作。如果对 -annotated 类使用显式指令，请注意这些过滤器将被禁用。如果使用切片，则应重新定义它们。@SpringBootApplication@ComponentScan@SpringBootApplication

如果要自定义主配置，可以使用嵌套类。与嵌套类（将用于代替应用程序的主配置）不同，嵌套类是除了应用程序的主要配置之外还使用的。@TestConfiguration@Configuration@TestConfiguration

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

如果使用测试批注来测试应用程序的更具体切片，则应避免在主方法的应用程序类上添加特定于特定区域的配置设置。

使用 Test Configuration Main 方法

通常，发现的测试配置将是您的主要 . 在大多数结构良好的应用程序中，此配置类还将包括用于启动应用程序的方法。@SpringBootTest@SpringBootApplicationmain

例如，以下是典型 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);
	}

}

在上面的示例中，该方法除了委托给之外不执行任何操作。但是，可以使用更复杂的方法在调用之前应用自定义项。mainSpringApplication.runmainSpringApplication.run

例如，下面是一个应用程序，用于更改横幅模式并设置其他配置文件：

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

}

由于方法中的自定义项可能会影响结果，因此您可能还希望使用该方法在测试中创建 used。默认情况下，不会调用您的方法，而是直接使用类本身来创建mainApplicationContextmainApplicationContext@SpringBootTestmainApplicationContext

如果要更改此行为，可以更改 to 或的属性。设置为时，如果找不到方法，测试将失败。当设置为该方法时，如果可用，则使用该方法，否则将使用标准加载机制。useMainMethod@SpringBootTestUseMainMethod.ALWAYSUseMainMethod.WHEN_AVAILABLEALWAYSmainWHEN_AVAILABLEmain

例如，以下测试将调用的方法以创建 . 如果 main 方法设置了其他配置文件，则这些配置文件将在启动时处于活动状态。mainMyApplicationApplicationContextApplicationContext

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

}

不包括测试配置

如果应用程序使用组件扫描（例如，如果使用或），您可能会发现仅为特定测试创建的顶级配置类会意外地被拾取到任何地方。@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() {
		// ...
	}

}

如果您直接使用（即不通过），则需要向它注册。有关详细信息，请参阅 Javadoc。@ComponentScan@SpringBootApplicationTypeExcludeFilter

导入的处理时间早于内部类，导入的配置将在通过组件扫描找到的任何配置之前处理。一般来说，这种排序差异没有明显的影响，但如果你依赖 Bean 覆盖，这是需要注意的。@TestConfiguration@TestConfiguration@TestConfiguration

如果您直接使用（即不通过），则需要向它注册。有关详细信息，请参阅 Javadoc。@ComponentScan@SpringBootApplicationTypeExcludeFilter

使用应用程序参数

如果应用程序需要参数，则可以使用属性注入它们。@SpringBootTestargs

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

}

使用模拟环境进行测试

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

使用 Spring MVC，我们可以使用 MockMvc 或来查询我们的 Web 端点，如以下示例所示：WebTestClient

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

}

如果您只想专注于 Web 图层而不开始一个完整的图层，请考虑改用 @WebMvcTest。ApplicationContext

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

}

在模拟环境中进行测试通常比使用完整的 servlet 容器运行更快。但是，由于模拟发生在 Spring MVC 层，因此无法使用 MockMvc 直接测试依赖于较低级别的 servlet 容器行为的代码。

例如，Spring Boot 的错误处理基于 servlet 容器提供的“错误页面”支持。这意味着，虽然您可以按预期测试 MVC 层引发和处理异常，但无法直接测试是否呈现了特定的自定义错误页面。如果需要测试这些较低级别的问题，可以启动完全运行的服务器，如下一节所述。

如果您只想专注于 Web 图层而不开始一个完整的图层，请考虑改用 @WebMvcTest。ApplicationContext

使用正在运行的服务器进行测试

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

注释可用于将实际使用的端口注入到测试中。为方便起见，需要对已启动的服务器进行 REST 调用的测试可以另外使用 WebTestClient，该客户端解析与正在运行的服务器的相对链接，并附带用于验证响应的专用 API，如以下示例所示：@LocalServerPort@Autowire

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

}

WebTestClient还可以与模拟环境一起使用，通过使用 .@AutoConfigureWebTestClient

此设置需要类路径。如果你不能或不会添加 webflux，Spring Boot 还提供了一个工具：spring-webfluxTestRestTemplate

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

}

WebTestClient还可以与模拟环境一起使用，通过使用 .@AutoConfigureWebTestClient

自定义 WebTestClient

要自定义 Bean，请配置 Bean。任何此类 Bean 都与用于创建的一起调用。WebTestClientWebTestClientBuilderCustomizerWebTestClient.BuilderWebTestClient

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

}

使用观测值

如果使用注释切片测试，它会自动配置 .@AutoConfigureObservabilityObservationRegistry

使用指标

无论类路径如何，在使用 .@SpringBootTest

如果需要将指标导出到其他后端作为集成测试的一部分，请使用 .@AutoConfigureObservability

如果使用注释切片测试，它会自动配置内存中的。注释不支持在切片测试中导出数据。@AutoConfigureObservabilityMeterRegistry@AutoConfigureObservability

使用跟踪

无论类路径如何，在使用 .@SpringBootTest

如果需要将这些组件作为集成测试的一部分，请使用 .@AutoConfigureObservability

如果您已创建自己的报告组件（例如自定义或），并且不希望它们在测试中处于活动状态，则可以使用注释来禁用它们。SpanExporterSpanHandler@ConditionalOnEnabledTracing

如果使用注释切片测试，它会自动配置 no-op 。注释不支持在切片测试中导出数据。@AutoConfigureObservabilityTracer@AutoConfigureObservability

嘲笑和窥探豆子

运行测试时，有时需要模拟应用程序上下文中的某些组件。例如，您可能在某些远程服务上有一个外观，而该外观在开发过程中不可用。当您想要模拟在真实环境中可能难以触发的故障时，模拟也很有用。

Spring Boot 包含一个注解，可用于为 . 您可以使用注释来添加新 Bean 或替换单个现有 Bean 定义。注释可以直接用于测试类、测试中的字段或类和字段。当在字段上使用时，也会注入创建的模拟实例。模拟 Bean 在每种测试方法后都会自动重置。@MockBeanApplicationContext@Configuration

如果您的测试使用了 Spring Boot 的测试注解之一（例如），则会自动启用此功能。若要以不同的排列方式使用此功能，必须显式添加侦听器，如以下示例所示：@SpringBootTest

import org.springframework.boot.test.mock.mockito.MockitoTestExecutionListener;
import org.springframework.boot.test.mock.mockito.ResetMocksTestExecutionListener;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;

@ContextConfiguration(classes = MyConfig.class)
@TestExecutionListeners({ MockitoTestExecutionListener.class, ResetMocksTestExecutionListener.class })
class MyTests {

	// ...

}

以下示例将现有 Bean 替换为模拟实现：RemoteService

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.mock.mockito.MockBean;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;

@SpringBootTest
class MyTests {

	@Autowired
	private Reverser reverser;

	@MockBean
	private RemoteService remoteService;

	@Test
	void exampleTest() {
		given(this.remoteService.getValue()).willReturn("spring");
		String reverse = this.reverser.getReverseValue(); // Calls injected RemoteService
		assertThat(reverse).isEqualTo("gnirps");
	}

}

@MockBean不能用于模拟在应用程序上下文刷新期间执行的 Bean 的行为。在执行测试时，应用程序上下文刷新已完成，配置模拟行为为时已晚。在这种情况下，我们建议使用一种方法来创建和配置模拟。@Bean

此外，您可以使用 Mockito 包装任何现有 bean 。有关完整的详细信息，请参阅 Javadoc。@SpyBeanspy

虽然 Spring 的测试框架在测试之间缓存应用程序上下文，并为共享相同配置的测试重用上下文，但缓存键的使用或影响缓存键，这很可能会增加上下文的数量。@MockBean@SpyBean

如果使用按名称引用参数的方法监视 Bean，则必须使用 . 这可确保在监视 Bean 后，参数名称可供缓存基础结构使用。@SpyBean@Cacheable-parameters

当您用于监视由 Spring 代理的 Bean 时，在某些情况下可能需要删除 Spring 的代理，例如，使用或设置期望时。用于执行此操作。@SpyBeangivenwhenAopTestUtils.getTargetObject(yourProxiedSpy)

import org.springframework.boot.test.mock.mockito.MockitoTestExecutionListener;
import org.springframework.boot.test.mock.mockito.ResetMocksTestExecutionListener;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;

@ContextConfiguration(classes = MyConfig.class)
@TestExecutionListeners({ MockitoTestExecutionListener.class, ResetMocksTestExecutionListener.class })
class MyTests {

	// ...

}

如果使用按名称引用参数的方法监视 Bean，则必须使用 . 这可确保在监视 Bean 后，参数名称可供缓存基础结构使用。@SpyBean@Cacheable-parameters

自动配置的测试

Spring Boot 的自动配置系统适用于应用程序，但有时对于测试来说可能有点太多了。它通常有助于仅加载测试应用程序“切片”所需的配置部分。例如，您可能希望测试 Spring MVC 控制器是否正确映射 URL，并且您不希望在这些测试中涉及数据库调用，或者您可能希望测试 JPA 实体，并且您在这些测试运行时对 Web 层不感兴趣。

该模块包含许多注释，可用于自动配置此类“切片”。它们中的每一个都以类似的方式工作，提供加载的注释以及可用于自定义自动配置设置的一个或多个注释。spring-boot-test-autoconfigure@…TestApplicationContext@AutoConfigure…

每个切片将组件扫描限制为适当的组件，并加载一组非常有限的自动配置类。如果需要排除其中之一，大多数批注都会提供属性。或者，您可以使用 .@…TestexcludeAutoConfiguration@ImportAutoConfiguration#exclude

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

也可以将注释与标准注释一起使用。如果您对“切片”应用程序不感兴趣，但想要一些自动配置的测试 Bean，则可以使用此组合。@AutoConfigure…@SpringBootTest

自动配置的 JSON 测试

若要测试对象 JSON 序列化和反序列化是否按预期工作，可以使用批注。自动配置可用的受支持的 JSON 映射器，该映射器可以是以下库之一：@JsonTest@JsonTest

杰克逊，任何豆子和任何杰克逊ObjectMapper@JsonComponentModule
Gson
Jsonb

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

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

Spring Boot 包括基于 AssertJ 的帮助程序，这些帮助程序与 JSONAssert 和 JsonPath 库一起使用，以检查 JSON 是否按预期显示。、、和类可以分别用于 Jackson、Gson、Jsonb 和 Strings。测试类上的任何帮助程序字段都可以在使用时。下面的示例显示了 Jackson 的测试类：JacksonTesterGsonTesterJsonbTesterBasicJsonTester@Autowired@JsonTest

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

}

JSON 帮助程序类也可以直接用于标准单元测试。为此，如果不使用，请在方法中调用帮助程序的方法。initFields@Before@JsonTest

如果您使用 Spring Boot 的基于 AssertJ 的帮助程序在给定的 JSON 路径上对数字值进行断言，则根据类型，您可能无法使用。相反，可以使用 AssertJ 来断言该值与给定条件匹配。例如，以下示例断言实际数字是接近的偏移量内的浮点值。isEqualTosatisfies0.150.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)));
	}

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

JSON 帮助程序类也可以直接用于标准单元测试。为此，如果不使用，请在方法中调用帮助程序的方法。initFields@Before@JsonTest

自动配置的 Spring MVC 测试

若要测试 Spring MVC 控制器是否按预期工作，请使用注释。自动配置 Spring MVC 基础结构，并将扫描的 Bean 限制为、、、和。使用注释时，不会扫描常规和 bean。可用于包括豆类。@WebMvcTest@WebMvcTest@Controller@ControllerAdvice@JsonComponentConverterGenericConverterFilterHandlerInterceptorWebMvcConfigurerWebMvcRegistrationsHandlerMethodArgumentResolver@Component@ConfigurationProperties@WebMvcTest@EnableConfigurationProperties@ConfigurationProperties

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

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

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

@WebMvcTest还自动配置 . Mock MVC 提供了一种强大的方法来快速测试 MVC 控制器，而无需启动完整的 HTTP 服务器。MockMvc

您还可以通过使用注释在非（例如）中自动配置。以下示例使用：MockMvc@WebMvcTest@SpringBootTest@AutoConfigureMockMvcMockMvc

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.docs.features.testing.springbootapplications.springmvctests.UserVehicleController;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.BDDMockito.given;
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;

@WebMvcTest(UserVehicleController.class)
class MyControllerTests {

	@Autowired
	private MockMvc mvc;

	@MockBean
	private UserVehicleService userVehicleService;

	@Test
	void testExample() throws Exception {
		given(this.userVehicleService.getVehicleDetails("sboot"))
			.willReturn(new VehicleDetails("Honda", "Civic"));
		this.mvc.perform(get("/sboot/vehicle").accept(MediaType.TEXT_PLAIN))
			.andExpect(status().isOk())
			.andExpect(content().string("Honda Civic"));
	}

}

如果需要配置自动配置的元素（例如，当应应用 servlet 过滤器时），则可以在注释中使用属性。@AutoConfigureMockMvc

如果您使用 HtmlUnit 和 Selenium，自动配置还会提供 HtmlUnit bean 和/或 Selenium bean。下面的示例使用 HtmlUnit：WebClientWebDriver

import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.docs.features.testing.springbootapplications.springmvctests.UserVehicleController;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;

@WebMvcTest(UserVehicleController.class)
class MyHtmlUnitTests {

	@Autowired
	private WebClient webClient;

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

}

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

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

如果类路径上有 Spring Security，也会扫描 bean。您可以使用Spring Security的测试支持，而不是完全禁用此类测试的安全性。有关如何使用 Spring Security 支持的更多详细信息，请参阅此使用 Spring Security 进行测试操作方法部分。@WebMvcTestWebSecurityConfigurerMockMvc

有时编写 Spring MVC 测试是不够的;Spring Boot 可以帮助您使用实际服务器运行完整的端到端测试。

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

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

您还可以通过使用注释在非（例如）中自动配置。以下示例使用：MockMvc@WebMvcTest@SpringBootTest@AutoConfigureMockMvcMockMvc

如果需要配置自动配置的元素（例如，当应应用 servlet 过滤器时），则可以在注释中使用属性。@AutoConfigureMockMvc

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

有时编写 Spring MVC 测试是不够的;Spring Boot 可以帮助您使用实际服务器运行完整的端到端测试。

自动配置的 Spring WebFlux 测试

要测试 Spring WebFlux 控制器是否按预期工作，您可以使用注释。自动配置 Spring WebFlux 基础结构，并将扫描的 Bean 限制为、、、、和。使用注释时，不会扫描常规和 bean。可用于包括豆类。@WebFluxTest@WebFluxTest@Controller@ControllerAdvice@JsonComponentConverterGenericConverterWebFilterWebFluxConfigurer@Component@ConfigurationProperties@WebFluxTest@EnableConfigurationProperties@ConfigurationProperties

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

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

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

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

您还可以通过使用注释在非（例如）中自动配置。下面的示例显示了同时使用和的类：WebTestClient@WebFluxTest@SpringBootTest@AutoConfigureWebTestClient@WebFluxTestWebTestClient

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.docs.features.testing.springbootapplications.springwebfluxtests.UserVehicleController;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.reactive.server.WebTestClient;

import static org.mockito.BDDMockito.given;

@WebFluxTest(UserVehicleController.class)
class MyControllerTests {

	@Autowired
	private WebTestClient webClient;

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

}

此设置仅受 WebFlux 应用程序支持，因为在模拟 Web 应用程序中使用此设置目前仅适用于 WebFlux。WebTestClient

@WebFluxTest无法检测通过功能 Web 框架注册的路由。要在上下文中测试 Bean，请考虑使用或 by using 导入您自己。RouterFunctionRouterFunction@Import@SpringBootTest

@WebFluxTest无法检测注册为类型的自定义安全配置。要将其包含在测试中，您需要导入用于注册 Bean 的配置，即使用或使用。@BeanSecurityWebFilterChain@Import@SpringBootTest

有时编写 Spring WebFlux 测试是不够的;Spring Boot 可以帮助您使用实际服务器运行完整的端到端测试。

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

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

此设置仅受 WebFlux 应用程序支持，因为在模拟 Web 应用程序中使用此设置目前仅适用于 WebFlux。WebTestClient

@WebFluxTest无法检测通过功能 Web 框架注册的路由。要在上下文中测试 Bean，请考虑使用或 by using 导入您自己。RouterFunctionRouterFunction@Import@SpringBootTest

有时编写 Spring WebFlux 测试是不够的;Spring Boot 可以帮助您使用实际服务器运行完整的端到端测试。

自动配置的 Spring GraphQL 测试

Spring GraphQL 提供了一个专用的测试支持模块;您需要将其添加到您的项目中：

Maven

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

Gradle

dependencies {
	testImplementation("org.springframework.graphql:spring-graphql-test")
	// Unless already present in the implementation configuration
	testImplementation("org.springframework.boot:spring-boot-starter-webflux")
}

此测试模块随附 GraphQlTester。测试仪在测试中被大量使用，因此请务必熟悉使用它。有一些变体，Spring Boot 将根据测试类型自动配置它们：GraphQlTester

在服务器端执行测试，没有客户端，也没有传输ExecutionGraphQlServiceTester
使用连接到服务器的客户端执行测试，无论是否具有实时服务器HttpGraphQlTester

Spring Boot 可帮助您使用注释测试 Spring GraphQL 控制器。自动配置 Spring GraphQL 基础架构，不涉及任何传输或服务器。这会将扫描的 Bean 限制为、、、、和。使用注释时，不会扫描常规和 bean。可用于包括豆类。@GraphQlTest@GraphQlTest@ControllerRuntimeWiringConfigurerJsonComponentConverterGenericConverterDataFetcherExceptionResolverInstrumentationGraphQlSourceBuilderCustomizer@Component@ConfigurationProperties@GraphQlTest@EnableConfigurationProperties@ConfigurationProperties

可以在附录中找到启用的自动配置列表。@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!");
	}

}

@SpringBootTest测试是完全集成的测试，涉及整个应用程序。使用随机或定义的端口时，会配置一个实时服务器，并自动贡献一个 Bean，以便您可以使用它来测试您的服务器。配置 MOCK 环境后，您还可以通过使用：HttpGraphQlTesterHttpGraphQlTester@AutoConfigureHttpGraphQlTester

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

}

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

自动配置的数据 Cassandra 测试

您可以使用来测试 Cassandra 应用程序。默认情况下，它会配置、扫描类并配置 Spring Data Cassandra 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 Cassandra 与 Spring Boot 一起使用的更多信息，请参阅“Cassandra”。@DataCassandraTestCassandraTemplate@Table@Component@ConfigurationProperties@DataCassandraTest@EnableConfigurationProperties@ConfigurationProperties

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

}

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

自动配置的数据 Couchbase 测试

您可以使用来测试 Couchbase 应用程序。默认情况下，它配置或，扫描类，并配置 Spring Data Couchbase 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 Couchbase 与 Spring Boot 一起使用的更多信息，请参阅本章前面的“Couchbase”。@DataCouchbaseTestCouchbaseTemplateReactiveCouchbaseTemplate@Document@Component@ConfigurationProperties@DataCouchbaseTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

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

自动配置的数据 Elasticsearch 测试

您可以使用它来测试 Elasticsearch 应用程序。默认情况下，它会配置、扫描类并配置 Spring Data Elasticsearch 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 Elasticsearch 与 Spring Boot 结合使用的更多信息，请参阅本章前面的“Elasticsearch”。@DataElasticsearchTestElasticsearchRestTemplate@Document@Component@ConfigurationProperties@DataElasticsearchTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

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

自动配置的数据 JPA 测试

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

使用注释时，不会扫描常规和 bean。可用于包括豆类。@Component@ConfigurationProperties@DataJpaTest@EnableConfigurationProperties@ConfigurationProperties

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

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

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 {

	// ...

}

数据 JPA 测试还可以注入 TestEntityManager bean，它提供了专门为测试设计的标准 JPA 的替代方案。EntityManager

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

如果需要，也可以使用 A。以下示例显示了正在使用的批注：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");
	}

}

内存中嵌入式数据库通常适用于测试，因为它们速度快且不需要任何安装。但是，如果您希望对实际数据库运行测试，则可以使用注释，如以下示例所示：@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 {

	// ...

}

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

自动配置的 JDBC 测试

@JdbcTest类似于，但用于仅需要 A 且不使用 Spring Data JDBC 的测试。默认情况下，它会配置内存中嵌入式数据库和 . 使用注释时，不会扫描常规和 bean。可用于包括豆类。@DataJpaTestDataSourceJdbcTemplate@Component@ConfigurationProperties@JdbcTest@EnableConfigurationProperties@ConfigurationProperties

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

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

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 {

}

如果您希望测试针对真实数据库运行，则可以采用与相同的方式使用注释。（请参阅 “自动配置的数据 JPA 测试”）@AutoConfigureTestDatabase@DataJpaTest

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

自动配置数据 JDBC 测试

@DataJdbcTest与使用 Spring Data JDBC 存储库的测试类似，但用于测试。默认情况下，它配置内存中嵌入式数据库、和 Spring Data JDBC 存储库。使用注释时只扫描子类，不扫描常规类和 bean。可用于包括豆类。@JdbcTestJdbcTemplateAbstractJdbcConfiguration@DataJdbcTest@Component@ConfigurationProperties@EnableConfigurationProperties@ConfigurationProperties

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

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

如果您希望测试针对真实数据库运行，则可以采用与相同的方式使用注释。（请参阅 “自动配置的数据 JPA 测试”）@AutoConfigureTestDatabase@DataJpaTest

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

自动配置的数据 R2DBC 测试

@DataR2dbcTest类似于，但适用于使用 Spring Data R2DBC 存储库的测试。默认情况下，它配置内存中嵌入式数据库、和 Spring Data R2DBC 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。@DataJdbcTestR2dbcEntityTemplate@Component@ConfigurationProperties@DataR2dbcTest@EnableConfigurationProperties@ConfigurationProperties

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

默认情况下，Data R2DBC 测试不是事务性的。

如果您希望测试针对真实数据库运行，则可以采用与相同的方式使用注释。（请参阅 “自动配置的数据 JPA 测试”）@AutoConfigureTestDatabase@DataJpaTest

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

自动配置的 jOOQ 测试

您可以以与 jOOQ 相关的测试类似的方式使用。由于 jOOQ 严重依赖与数据库模式相对应的基于 Java 的模式，因此使用现有的模式。如果要将其替换为内存中数据库，可以使用这些设置来覆盖这些设置。（有关将 jOOQ 与 Spring Boot 一起使用的更多信息，请参阅“使用 jOOQ”。使用注释时，不会扫描常规和 bean。可用于包括豆类。@JooqTest@JdbcTestDataSource@AutoConfigureTestDatabase@Component@ConfigurationProperties@JooqTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

JOOQ 测试是事务性的，默认情况下会在每个测试结束时回滚。如果这不是您想要的，您可以禁用测试或整个测试类的事务管理，如 JDBC 示例中所示。

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

自动配置的数据 MongoDB 测试

您可以使用来测试 MongoDB 应用程序。默认情况下，它会配置、扫描类并配置 Spring Data MongoDB 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 MongoDB 与 Spring Boot 一起使用的更多信息，请参阅“MongoDB”。@DataMongoTestMongoTemplate@Document@Component@ConfigurationProperties@DataMongoTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

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

自动配置的数据 Neo4j 测试

您可以使用测试 Neo4j 应用程序。默认情况下，它会扫描类，并配置 Spring Data Neo4j 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 Neo4J 与 Spring Boot 一起使用的更多信息，请参阅“Neo4j”。@DataNeo4jTest@Node@Component@ConfigurationProperties@DataNeo4jTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

默认情况下，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 {

}

反应式访问不支持事务性测试。如果使用此样式，则必须按上述方式配置测试。@DataNeo4jTest

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

反应式访问不支持事务性测试。如果使用此样式，则必须按上述方式配置测试。@DataNeo4jTest

自动配置的数据 Redis 测试

您可以使用来测试 Redis 应用程序。默认情况下，它会扫描类并配置 Spring Data Redis 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 Redis 与 Spring Boot 结合使用的更多信息，请参阅“Redis”。@DataRedisTest@RedisHash@Component@ConfigurationProperties@DataRedisTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

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

自动配置的数据LDAP测试

可用于测试 LDAP 应用程序。默认情况下，它会配置内存中嵌入式 LDAP（如果可用），配置、扫描类并配置 Spring Data LDAP 存储库。使用注释时，不会扫描常规和 bean。可用于包括豆类。（有关将 LDAP 与 Spring Boot 一起使用的更多信息，请参阅“LDAP”。@DataLdapTestLdapTemplate@Entry@Component@ConfigurationProperties@DataLdapTest@EnableConfigurationProperties@ConfigurationProperties

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

	// ...

}

内存中嵌入式 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 {

	// ...

}

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

自动配置的 REST 客户端

您可以使用注释来测试 REST 客户端。默认情况下，它会自动配置 Jackson、GSON 和 Jsonb 支持，配置 a 和 a ，并添加对的支持。使用注释时，不会扫描常规和 bean。可用于包括豆类。@RestClientTestRestTemplateBuilderRestClient.BuilderMockRestServiceServer@Component@ConfigurationProperties@RestClientTest@EnableConfigurationProperties@ConfigurationProperties

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

应使用的 or 属性指定要测试的特定 Bean。valuecomponents@RestClientTest

当在被测 Bean 中使用 a 并在构建时被调用时，应从期望中省略根 URI，如以下示例所示：RestTemplateBuilderRestTemplateBuilder.rootUri(String rootUri)RestTemplateMockRestServiceServer

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

}

在被测 Bean 中使用 a 或使用 without calling 时，必须在期望中使用完整的 URI，如以下示例所示：RestClient.BuilderRestTemplateBuilderrootUri(String rootURI)MockRestServiceServer

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

}

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

自动配置的 Spring REST Docs 测试

您可以使用注释在测试中使用 Spring REST Docs 和 Mock MVC、REST Assured 或 WebTestClient。它消除了Spring REST Docs中对JUnit扩展的需求。@AutoConfigureRestDocs

@AutoConfigureRestDocs可用于覆盖默认输出目录（如果您使用的是 Maven 或 Gradle）。它还可用于配置出现在任何记录的 URI 中的主机、方案和端口。target/generated-snippetsbuild/generated-snippets

使用模拟 MVC 自动配置的 Spring REST Docs 测试

@AutoConfigureRestDocs自定义 Bean 以在测试基于 servlet 的 Web 应用程序时使用 Spring REST Docs。您可以使用它来注入它，并在测试中使用它，就像通常使用 Mock MVC 和 Spring REST Docs 时一样，如以下示例所示：MockMvc@Autowired

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.MockMvc;

import static org.springframework.restdocs.mockmvc.MockMvcRestDocumentation.document;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(UserController.class)
@AutoConfigureRestDocs
class MyUserDocumentationTests {

	@Autowired
	private MockMvc mvc;

	@Test
	void listUsers() throws Exception {
		this.mvc.perform(get("/users").accept(MediaType.TEXT_PLAIN))
			.andExpect(status().isOk())
			.andDo(document("list-users"));
	}

}

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

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

}

如果要利用 Spring REST Docs 对参数化输出目录的支持，可以创建一个 bean。使用此结果处理程序进行自动配置调用，从而使每个调用自动生成默认代码段。以下示例显示了正在定义的：RestDocumentationResultHandleralwaysDoMockMvcRestDocumentationResultHandler

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

}

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

@AutoConfigureRestDocs在测试反应式 Web 应用程序时也可以使用。你可以像在使用 Spring REST Docs 时一样，在测试中使用它来注入它，如以下示例所示：WebTestClient@Autowired@WebFluxTest

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

}

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

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

}

如果要利用 Spring REST Docs 对参数化输出目录的支持，可以使用 a 为每个实体交换结果配置使用者。以下示例显示了这样的定义：WebTestClientBuilderCustomizerWebTestClientBuilderCustomizer

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

}

使用 REST 保证自动配置的 Spring REST Docs 测试

@AutoConfigureRestDocs使预配置为使用 Spring REST Docs 的 Bean 可用于您的测试。您可以使用它来注入它，并在测试中使用它，就像通常使用 REST Assured 和 Spring REST Docs 时一样，如以下示例所示：RequestSpecification@Autowired

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

}

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

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

}

自动配置的 Spring Web Services 测试

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

您可以使用 Spring Web Services 项目测试调用 Web 服务的应用程序。默认情况下，它会配置一个模拟 Bean 并自动自定义您的 . （有关将 Web 服务与 Spring Boot 一起使用的更多信息，请参阅“Web 服务”。@WebServiceClientTestWebServiceServerWebServiceTemplateBuilder

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

}

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

可用于测试使用 Spring Web Services 项目实现 Web 服务的应用程序。缺省情况下，它配置一个可用于调用 Web 服务终结点的 Bean。（有关将 Web 服务与 Spring Boot 一起使用的更多信息，请参阅“Web 服务”。@WebServiceServerTestMockWebServiceClient

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

以下示例显示了正在使用的批注：@WebServiceServerTest

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.docs.features.testing.springbootapplications.autoconfiguredwebservices.server.ExampleEndpoint;
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>")));
	}

}

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

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

其他自动配置和切片

每个切片都提供一个或多个注释，即定义应作为切片的一部分包含的自动配置。通过创建自定义注释或添加到测试中，可以逐个测试添加其他自动配置，如以下示例所示：@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 {

}

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

或者，可以通过将切片注释注册到存储在文件中来为切片注释的任何使用添加其他自动配置，如以下示例所示：META-INF/spring

META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.JdbcTest.imports

com.example.IntegrationAutoConfiguration

在此示例中，在每个用 . 注释的测试上启用。com.example.IntegrationAutoConfiguration@JdbcTest

您可以在此文件中使用注释。#

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

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

您可以在此文件中使用注释。#

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

用户配置和切片

如果以合理的方式构建代码，则默认情况下将使用类作为测试的配置。@SpringBootApplication

因此，重要的是不要将特定于其功能特定区域的配置设置乱扔给应用程序的主类。

假设您正在使用 Spring Data MongoDB，您依赖它的自动配置，并且您已经启用了审计。您可以按如下方式定义：@SpringBootApplication

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

@SpringBootApplication
@EnableMongoAuditing
public class MyApplication {

	// ...

}

因为这个类是测试的源配置，所以任何切片测试实际上都会尝试启用 Mongo 审计，这绝对不是你想要做的。建议的方法是将特定于区域的配置移动到与应用程序相同的级别的单独类，如以下示例所示：@Configuration

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

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

	// ...

}

根据应用程序的复杂性，您可以为自定义设置设置一个类，也可以为每个域区域使用一个类。后一种方法允许您在某个测试中启用它，如有必要，使用注释。有关何时可能希望为切片测试启用特定类的更多详细信息，请参阅此操作方法部分。@Configuration@Import@Configuration

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

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

}

但是，下面的配置将导致测试切片加载自定义。WebMvcConfigurer

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

@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {

	// ...

}

另一个混淆的来源是类路径扫描。假设您以合理的方式构建代码，但需要扫描其他包。应用程序可能类似于以下代码：

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

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

	// ...

}

这样做会有效地覆盖默认组件扫描指令，其副作用是扫描这两个包，而不管您选择哪个切片。例如，似乎突然扫描应用程序的组件和用户配置。同样，将自定义指令移动到单独的类是解决此问题的好方法。@DataJpaTest

如果这不是您的选项，则可以在测试的层次结构中创建一个位置，以便改用它。或者，您可以指定测试源，这将禁用查找默认源的行为。@SpringBootConfiguration

使用 Spock 测试 Spring Boot 应用程序

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