7.9.3. 测试 Spring Boot 应用程序

Spring Boot 应用程序是 Spring ApplicationContext，因此除了您通常使用普通 Spring 上下文执行的操作之外，无需进行任何特别的测试即可对其进行测试。

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

Spring Boot 提供了@SpringBootTest注解，当您需要 Spring Boot 特性时，可以将其用作标准spring-test @ContextConfiguration注解的替代方案。该注解的工作原理是通过 SpringApplication 创建测试中使用的 ApplicationContext. 除了@SpringBootTest许多其他注解之外，还提供了用于。

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

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

MOCK（默认）：加载web ApplicationContext并提供模拟网络环境。使用此注解时不启动嵌入式服务器。如果您的类路径上没有可用的 Web 环境，则此模式会透明地回退到创建常规的 non-web ApplicationContext。它可以与您的 Web 应用程序结合使用用于基于模拟的测试。
RANDOM_PORT: 加载WebServerApplicationContext并提供一个真实的网络环境。嵌入式服务器会启动并侦听随机端口。
DEFINED_PORT: 加载WebServerApplicationContext并提供一个真实的网络环境。嵌入式服务器会启动并侦听定义的端口（来自您的application.properties）或默认的8080端口.
NONE：通过使用SpringApplication加载一个ApplicationContext但不提供任何Web 环境（模拟或其他）。

如果您的测试是@Transactional，默认情况下，它会在每个测试方法结束时回滚事务。然而，由于使用RANDOM_PORT或DEFINED_PORT隐含地提供了一个真正的 servlet 环境，HTTP 客户端和服务器在不同的线程中运行，因此在不同的事务中运行。在这种情况下，服务器上启动的任何事务都不会回滚。
如果您的应用程序为管理服务器使用不同的端口，使用webEnvironment = WebEnvironment.RANDOM_PORT的 @SpringBootTest还将在单独的随机端口上启动管理服务器。

7.9.3.1. 检测 Web 应用程序类型

如果 Spring MVC 可用，则配置常规的基于 MVC 的应用程序上下文。如果您只有 Spring WebFlux，我们将检测到它并配置一个基于 WebFlux 的应用程序上下文。

如果两者都存在，则 Spring MVC 优先。如果要在这种情况下测试响应式 Web 应用程序，则必须设置spring.main.web-application-type属性：

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

    // ...

}

7.9.3.2. 检测测试配置

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

在测试 Spring Boot 应用程序时，通常不需要这样做。只要您没有明确定义，Spring Boot 的@*Test注解就会自动搜索您的主要配置。

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

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

7.9.3.3. 排除测试配置

如果您的应用程序使用组件扫描（例如，如果您使用@SpringBootApplication或@ComponentScan），您可能会发现仅为特定测试创建的顶级配置类意外地在各处被拾取。

@SpringBootTest
@Import(MyTestsConfiguration.class)
class MyTests {

    @Test
    void exampleTest() {
        // ...
    }

}

7.9.3.4. 使用应用程序参数

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

}

7.9.3.5. 使用模拟环境进行测试

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

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

}

@SpringBootTest
@AutoConfigureWebTestClient
class MyMockWebTestClientTests {

    @Test
    void exampleTest(@Autowired WebTestClient webClient) {
        webClient
            .get().uri("/")
            .exchange()
            .expectStatus().isOk()
            .expectBody(String.class).isEqualTo("Hello World");
    }

}

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

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

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

}

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

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class MyRandomPortTestRestTemplateTests {

    @Test
    void exampleTest(@Autowired TestRestTemplate restTemplate) {
        String body = restTemplate.getForObject("/", String.class);
        assertThat(body).isEqualTo("Hello World");
    }

}

7.9.3.7. 自定义 WebTestClient

要自定义WebTestClientbean，请配置一个WebTestClientBuilderCustomizerbean。任何此类 bean 都使用WebTestClient.Builder创建WebTestClient.

7.9.3.8. 使用 JMX

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

@ExtendWith(SpringExtension.class)
@SpringBootTest(properties = "spring.jmx.enabled=true")
@DirtiesContext
class MyJmxTests {

    @Autowired
    private MBeanServer mBeanServer;

    @Test
    void exampleTest() {
        assertThat(this.mBeanServer.getDomains()).contains("java.lang");
        // ...
    }

}

7.9.3.9. 使用指标

无论您的类路径如何，使用 @SpringBootTest 时，仪表注册表（内存中支持的除外）都不会自动配置。

如果您需要在集成测试中将指标导出到不同的后端，请使用@AutoConfigureMetrics.

7.9.3.10. 模拟和窥探 Bean

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

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

如果您的测试使用 Spring Boot 的测试注解之一（例如@SpringBootTest），则会自动启用此功能。要以不同的排列方式使用此功能，必须显式添加侦听器，如以下示例所示：
@ContextConfiguration(classes = MyConfig.class)
@TestExecutionListeners({ MockitoTestExecutionListener.class, ResetMocksTestExecutionListener.class })
class MyTests {

 // ...

}

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

@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方法来创建和配置模拟。

此外，您可以使用 @SpyBean 将任何现有的 bean 与 Mockito spy 包装在一起。有关完整详细信息，请参阅 Javadoc。

CGLib 代理，例如为作用域 bean 创建的代理，将代理方法声明为final. 这会阻止 Mockito 正常运行，因为它无法在其默认配置中模拟或监视final方法。如果您想模拟或监视这样的 bean，请将 Mockito 配置为通过org.mockito:mockito-inline添加到应用程序的测试依赖项来使用其内联模拟生成器。这允许 Mockito 模拟和监视final方法。虽然 Spring 的测试框架在测试之间缓存应用程序上下文，并为共享相同配置的测试重用上下文，但使用@MockBean或@SpyBean影响缓存键，这很可能会增加上下文的数量。如果您使用@SpyBean通过名称引用参数的@Cacheable方法来监视 bean ，则您的应用程序必须使用-parameters. 这确保了一旦 bean 被监视，参数名称对缓存基础设施可用。当您使用@SpyBean用于监视由 Spring 代理的 bean 时，您可能需要在某些情况下删除 Spring 的代理，例如在使用given或when设置期望值时。使用AopTestUtils.getTargetObject(yourProxiedSpy)也需要这样做。

7.9.3.11. 自动配置的测试

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

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

每个切面将组件扫描限制到适当的组件并加载一组非常有限的自动配置类。如果您需要排除其中一个，大多数@…Test注解都提供了一个excludeAutoConfiguration属性。或者，您也可以使用@ImportAutoConfiguration#exclude.
不支持通过在一个测试中使用多个@…Test注解来包含多个“切面” 。如果您需要多个“切面”，请选择其中一个@…Test注解并手动包含其他“切面”的@AutoConfigure…注解。
如果您对“切面”您的应用程序不感兴趣，但您想要一些自动配置的测试 bean，您也可以将@AutoConfigure…注解与标准@SpringBootTest注解一起使用。

7.9.3.12. 自动配置的 JSON 测试

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

JacksonObjectMapper，任何@JsonComponentbean和任何Jackson Module的
Gson
Jsonb

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

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

@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 辅助类也可以直接用于标准单元测试。为此，如果您不使用 @JsonTest，请在 @Before 方法中调用帮助器的 initFields 方法。

如果您使用 Spring Boot 的基于 AssertJ 的帮助器对给定 JSON 路径中的数字值进行断言，则可能无法使用，isEqualTo具体取决于类型。相反，您可以使用 AssertJsatisfies断言该值与给定条件是否匹配。例如，以下示例断言实际数字是否接近浮点值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)));
}

8.3.13. 自动配置的 Spring MVC 测试

要测试 Spring MVC 控制器是否按预期工作，请使用@WebMvcTest注解。 @WebMvcTest自动配置 Spring MVC 基础结构并将扫描的 bean 限制为@Controller, @ControllerAdvice, @JsonComponent, Converter, GenericConverter, Filter, HandlerInterceptor, WebMvcConfigurer,WebMvcRegistrations和HandlerMethodArgumentResolver. 使用注解@WebMvcTest 时不会扫描常规@Component和@ConfigurationPropertiesbean。@EnableConfigurationProperties可用于包含@ConfigurationPropertiesbean。

如果您需要注册额外的组件，例如 Jackson Module，您可以通过在测试中使用@Import来导入额外的配置类。通常，@WebMvcTest仅限于单个控制器，并与@MockBean结合使用，为所需的协作者提供模拟实现。

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

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

@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 WebClientbean 和/或 Selenium WebDriverbean。以下示例使用 HtmlUnit：

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

}

7.9.3.14. 自动配置的 Spring WebFlux 测试

您还可以在非@WebFluxTest中通过使用@AutoConfigureWebTestClient注解来自动配置WebTestClient（例如@SpringBootTest）。以下示例使用WebTestClient和@WebFluxTest：

@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 应用程序支持，因为在模拟应用程序中使用WebTestClient目前仅适用于 WebFlux。

7.9.3.15。自动配置的 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")
}

ExecutionGraphQlServiceTester在服务器端执行测试，没有客户端也没有实际传输
使用HttpGraphQlTester连接到服务器的客户端执行测试，有或没有服务器都可以

如果您需要注册额外的组件，例如 Jackson Module，您可以在您的测试中使用@Import导入额外的配置类。通常，@GraphQlTest仅限于一组控制器并与@MockBean注解结合使用，为所需的协作者提供模拟实现。

@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测试是完整的集成测试，涉及整个应用程序。当使用随机或定义的端口时，会配置一个实时服务器并自动提供一个HttpGraphQlTester bean，以便您可以使用它来测试您的服务器。配置 MOCK 环境后，您还可以通过使用以下命令@AutoConfigureHttpGraphQlTester 注解测试类来请求HttpGraphQlTester bean ：

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

}

8.3.16. 自动配置的数据 Cassandra 测试

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

@DataCassandraTest
class MyDataCassandraTests {

    @Autowired
    private SomeRepository repository;

}

7.9.3.17. 自动配置的 Data Couchbase 测试

@DataCouchbaseTest
class MyDataCouchbaseTests {

    @Autowired
    private SomeRepository repository;

    // ...

}

7.9.3.18. 自动配置的数据 Elasticsearch 测试

@DataElasticsearchTest
class MyDataElasticsearchTests {

    @Autowired
    private SomeRepository repository;

    // ...

}

7.9.3.19. 自动配置的数据 JPA 测试

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

使用注解@DataJpaTest 时不会扫描常规@Component和@ConfigurationPropertiesbean。@EnableConfigurationProperties可用于包含@ConfigurationProperties bean。

@DataJpaTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyNonTransactionalTests {

    // ...

}

@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注解，如以下示例所示：

@DataJpaTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
class MyRepositoryTests {

    // ...

}

7.9.3.20. 自动配置的 JDBC 测试

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

@JdbcTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyTransactionalTests {

}

7.9.3.21. 自动配置的数据 JDBC 测试

@DataJdbcTest类似于@JdbcTest但适用于使用 Spring Data JDBC 存储库的测试。默认情况下，它配置内存中的嵌入式数据库、JdbcTemplate和 Spring Data JDBC 存储库。使用@DataJdbcTest注解时只AbstractJdbcConfiguration扫描子类，不扫描常规@Component和@ConfigurationPropertiesbean。 @EnableConfigurationProperties可用于包含@ConfigurationPropertiesbean。

7.9.3.22。自动配置的 jOOQ 测试

@JooqTest
class MyJooqTests {

    @Autowired
    private DSLContext dslContext;

    // ...

}

7.9.3.23. 自动配置数据 MongoDB 测试

@DataMongoTest
class MyDataMongoDbTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    // ...

}

内存中嵌入式 MongoDB 通常适用于测试，因为它速度快且不需要任何开发人员安装。但是，如果您更喜欢针对真正的 MongoDB 服务器运行测试，则应排除嵌入式 MongoDB 自动配置，如以下示例所示：

@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
class MyDataMongoDbTests {

    // ...

}

7.9.3.24. 自动配置的数据 Neo4j 测试

@DataNeo4jTest
class MyDataNeo4jTests {

    @Autowired
    private SomeRepository repository;

    // ...

}

@DataNeo4jTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MyDataNeo4jTests {

}

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

7.9.3.25. 自动配置的数据 Redis 测试

@DataRedisTest
class MyDataRedisTests {

    @Autowired
    private SomeRepository repository;

    // ...

}

7.9.3.26. 自动配置的数据 LDAP 测试

@DataLdapTest
class MyDataLdapTests {

    @Autowired
    private LdapTemplate ldapTemplate;

    // ...

}

内存中嵌入式 LDAP 通常适用于测试，因为它速度快且不需要任何开发人员安装。但是，如果您更喜欢针对真实的 LDAP 服务器运行测试，则应排除嵌入式 LDAP 自动配置，如以下示例所示：

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

    // ...

}

7.9.3.27. 自动配置的 REST 客户端

您可以使用@RestClientTest注解来测试 REST 客户端。默认情况下，它会自动配置 Jackson、GSON 和 Jsonb 支持，配置RestTemplateBuilder并添加MockRestServiceServer. 使用注解@RestClientTest 时不会扫描常规@Component和@ConfigurationPropertiesbean。@EnableConfigurationProperties可用于包含@ConfigurationPropertiesbean。

@RestClientTest(RemoteVehicleDetailsService.class)
class MyRestClientTests {

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

}

7.9.3.28. 自动配置的 Spring REST 文档测试

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

使用 Mock MVC 自动配置 Spring REST 文档测试

在测试基于 servlet 的 Web 应用程序时可以使用@AutoConfigureRestDocs自定义MockMvcbean 以使用 Spring REST Docs。您可以像使用 Mock MVC 和 Spring REST Docs 时一样在测试中使用和使用它，如以下示例所示：

@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 配置的控制比@AutoConfigureRestDocs的属性提供的更多，则可以使用RestDocsMockMvcConfigurationCustomizerbean，如以下示例所示：

@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsMockMvcConfigurationCustomizer {

    @Override
    public void customize(MockMvcRestDocumentationConfigurer configurer) {
        configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
    }

}

如果你想利用 Spring REST Docs 对参数化输出目录的支持，你可以创建一个RestDocumentationResultHandlerbean。使用此结果处理程序进行自动配置调用alwaysDo，从而导致每个mockMvc调用自动生成默认片段。下面的例子显示了一个被定义的RestDocumentationResultHandler：

@TestConfiguration(proxyBeanMethods = false)
public class MyResultHandlerConfiguration {

    @Bean
    public RestDocumentationResultHandler restDocumentation() {
        return MockMvcRestDocumentation.document("{method-name}");
    }

}

使用 WebTestClient 自动配置 Spring REST 文档测试

也可以在测试响应式 Web 应用程序的WebTestClient时使用@AutoConfigureRestDocs。您可以像使用 Spring REST Docs 时一样在测试中使用@WebFluxTest和使用@Autowired，如以下示例所示：

@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 配置的控制比的属性提供的更多@AutoConfigureRestDocs，则可以使用RestDocsWebTestClientConfigurationCustomizerbean，如以下示例所示：

@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsWebTestClientConfigurationCustomizer {

    @Override
    public void customize(WebTestClientRestDocumentationConfigurer configurer) {
        configurer.snippets().withEncoding("UTF-8");
    }

}

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

@TestConfiguration(proxyBeanMethods = false)
public class MyWebTestClientBuilderCustomizerConfiguration {

    @Bean
    public WebTestClientBuilderCustomizer restDocumentation() {
        return (builder) -> builder.entityExchangeResultConsumer(document("{method-name}"));
    }

}

带有 REST Assured 的自动配置 Spring REST 文档测试

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

@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 配置的控制比@AutoConfigureRestDocs的属性提供的更多，则可以使用RestDocsRestAssuredConfigurationCustomizer bean，如以下示例所示：

@TestConfiguration(proxyBeanMethods = false)
public class MyRestDocsConfiguration implements RestDocsRestAssuredConfigurationCustomizer {

    @Override
    public void customize(RestAssuredRestDocumentationConfigurer configurer) {
        configurer.snippets().withTemplateFormat(TemplateFormats.markdown());
    }

}

7.9.3.29. 自动配置的 Spring Web 服务测试

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

@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 服务服务器测试

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

}

7.9.3.30. 额外的自动配置和切面

每个切面提供一个或多个@AutoConfigure…注解，即定义应作为切面一部分包含的自动配置。通过创建自定义@AutoConfigure…注解或通过@ImportAutoConfiguration添加到测试中，可以逐个测试添加其他自动配置，如以下示例所示：

@JdbcTest
@ImportAutoConfiguration(IntegrationAutoConfiguration.class)
class MyJdbcTests {

}

确保不要使用常规@Import注解来导入自动配置，因为它们是由 Spring Boot 以特定方式处理的。或者，可以为切面注解的任何使用添加额外的自动配置，方法是将它们注册到存储的META-INF/spring文件中，如以下示例所示： META-INF/spring/org.springframework.boot.test.autoconfigure.jdbc.JdbcTest.imports

com.example.IntegrationAutoConfiguration

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

您可以通过在此文件中使用#注解。

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

7.9.3.31. 用户配置和切面

然后，重要的是不要在应用程序的主类中乱扔特定于其功能特定区域的配置设置。

假设您使用的是 Spring Batch，并且您依赖于它的自动配置。您可以定义@SpringBootApplication如下：

@SpringBootApplication
@EnableBatchProcessing
public class MyApplication {

    // ...

}

因为这个类是测试的源配置，所以任何切面测试实际上都会尝试启动 Spring Batch，这绝对不是你想要做的。推荐的方法是将特定于区域的配置移动到与您的应用程序处于同一级别的单独@Configuration类中，如以下示例所示：

@Configuration(proxyBeanMethods = false)
@EnableBatchProcessing
public class MyBatchConfiguration {

    // ...

}

@Configuration(proxyBeanMethods = false)
public class MyWebConfiguration {

    @Bean
    public WebMvcConfigurer testConfigurer() {
        return new WebMvcConfigurer() {
            // ...
        };
    }

}

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

@Component
public class MyWebMvcConfigurer implements WebMvcConfigurer {

    // ...

}

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

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

    // ...

}

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

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

7.9.3.32. 使用 Spock 测试 Spring Boot 应用程序

上一页7.9.2. 测试 Spring 应用程序下一页7.9.4. 测试容器

最后更新于1年前

这有帮助吗？