This content originally appeared on DEV Community and was authored by Gilson Silva
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
| Característica | TestRestTemplate | WebTestClient |
|---|---|---|
| Paradigma | Imperativo | Reativo |
| Facilidade de Uso | Simples e familiar | API fluente, mais flexível, mas mais complexa |
| Suporte a WebFlux | Não | Sim |
| Controle sobre a Resposta | Básico | Avançado |
| Necessidade de Servidor | Sim | Não |
| Velocidade dos Testes | Mais lento | Mais rápido |
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.
This content originally appeared on DEV Community and was authored by Gilson Silva
Gilson Silva | Sciencx (2024-10-01T22:39:25+00:00) Testes Subcutâneos – Comparação entre TestRestTemplate e WebTestClient em Testes de Integração 🧑💻. Retrieved from https://www.scien.cx/2024/10/01/testes-subcutaneos-comparacao-entre-testresttemplate-e-webtestclient-em-testes-de-integracao-%f0%9f%a7%91%f0%9f%92%bb/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.