Ao realizar testes de integração em aplicações Spring Boot, duas abordagens populares para testar endpoints REST são o uso de TestRestTemplate e WebTestClient. Ambas as abordagens têm suas vantagens e desvantagens, e a escolha entre elas depende do contexto e das necessidades do projeto.

Neste artigo, vamos comparar essas duas abordagens com base em dois exemplos de código.

1. Testando com TestRestTemplate

@Test
@DisplayName("Create Planet Return Created")
void createPlanet_ReturnCreated() {
    var sut = restTemplate.postForEntity(URL, PLANET_REQUEST_IT, PlanetResponse.class);

    assertThat(sut.getStatusCode()).isEqualTo(HttpStatus.CREATED);

    assertThat(sut.getBody()).isNotNull();

    assertThat(sut.getBody().name()).isEqualTo(PLANET_REQUEST_IT.name());
    assertThat(sut.getBody().terrain()).isEqualTo(PLANET_REQUEST_IT.terrain());
    assertThat(sut.getBody().climate()).isEqualTo(PLANET_REQUEST_IT.climate());
}

Vantagens do TestRestTemplate:

• Simplicidade: O TestRestTemplate é fácil de usar e se integra bem com o Spring Boot. Ele é uma extensão do RestTemplate, o que o torna familiar para desenvolvedores que já utilizam o RestTemplate em suas aplicações.
• Testes de Integração Completa: O TestRestTemplate é ideal para testes de integração completos, onde o servidor da aplicação é iniciado em uma porta real (ou aleatória) e as requisições são feitas como se fossem de um cliente externo.
• Suporte a Vários Métodos HTTP: Ele oferece suporte a todos os métodos HTTP (GET, POST, PUT, DELETE, etc.) e permite testar a API de forma semelhante a como um cliente real interagiria com ela.

Desvantagens do TestRestTemplate:

• Menos Flexível para Testes Reativos: O TestRestTemplate não é ideal para aplicações reativas, como aquelas que utilizam o Spring WebFlux. Ele foi projetado para o paradigma de programação imperativa.
• Menos Controle sobre a Resposta: Embora seja possível verificar o status e o corpo da resposta, o TestRestTemplate não oferece tantas opções de verificação e manipulação da resposta quanto o WebTestClient.

2. Testando com WebTestClient

@Test
@DisplayName("Create Planet With WebTestClient Return Created")
void createPlanet_WithWebTestClient_ReturnsCreated() {
    var sut = webTestClient.post().uri(URL).bodyValue(PLANET_REQUEST_IT)
            .exchange().expectStatus().isCreated().expectBody(PlanetResponse.class)
            .returnResult().getResponseBody();

    assertThat(sut).isNotNull();
    assertThat(sut.name()).isEqualTo(PLANET_REQUEST_IT.name());
    assertThat(sut.climate()).isEqualTo(PLANET_REQUEST_IT.climate());
    assertThat(sut.terrain()).isEqualTo(PLANET_REQUEST_IT.terrain());
}

Vantagens do WebTestClient:

• Suporte a Aplicações Reativas: O WebTestClient foi projetado para trabalhar com o Spring WebFlux, o que o torna ideal para testar aplicações reativas. Ele suporta fluxos assíncronos e reativos, permitindo testar APIs que utilizam Mono e Flux.
• Maior Controle sobre a Resposta: O WebTestClient oferece uma API fluente que permite verificar o status da resposta, o corpo e até mesmo os headers de forma mais detalhada. Isso proporciona maior flexibilidade e controle sobre o que está sendo testado.
• Testes Sem Necessidade de Servidor Real: O WebTestClient pode ser usado para testar controladores diretamente, sem a necessidade de iniciar um servidor real. Isso pode acelerar os testes e torná-los mais eficientes.

Desvantagens do WebTestClient:

• Curva de Aprendizado: A API do WebTestClient pode ser um pouco mais complexa para desenvolvedores que estão acostumados com o RestTemplate ou TestRestTemplate. A abordagem fluente pode exigir um pouco mais de tempo para se acostumar.
• Menos Adequado para Aplicações Imperativas: Embora o WebTestClient possa ser usado em aplicações não reativas, ele é mais adequado para o paradigma reativo. Para aplicações imperativas, o TestRestTemplate pode ser uma escolha mais simples e direta.

Comparação Direta

Conclusão

A escolha entre TestRestTemplate e WebTestClient depende do tipo de aplicação que você está desenvolvendo e do nível de controle que você precisa nos seus testes. Se você está trabalhando com uma aplicação imperativa e precisa de testes simples e diretos, o TestRestTemplate pode ser a melhor escolha. No entanto, se você está desenvolvendo uma aplicação reativa ou precisa de mais controle sobre as respostas HTTP, o WebTestClient oferece uma abordagem mais poderosa e flexível.

Ambas as ferramentas são úteis em diferentes contextos, e entender suas diferenças pode ajudar a escolher a abordagem certa para seus testes de integração.