Acquisizione e verifica dei dati di risposta con REST-assicurato

REST Top

Ho appena annunciato il nuovo corso Learn Spring , incentrato sui fondamenti di Spring 5 e Spring Boot 2:

>> SCOPRI IL CORSO

1. Panoramica

In questo tutorial, discuteremo come testare i servizi REST utilizzando REST-assicurato, concentrandoci sull'acquisizione e sulla convalida dei dati di risposta dalle nostre API REST .

2. Configurazione per la classe di prova

Nei tutorial precedenti, abbiamo esplorato REST-assicurato in generale e abbiamo mostrato come manipolare intestazioni, cookie e parametri delle richieste.

Basandosi su questa configurazione esistente, abbiamo aggiunto un semplice controller REST, AppController , che chiama internamente un servizio, AppService . Useremo queste classi nei nostri esempi di test.

Per creare la nostra classe di test, dobbiamo fare un po 'più di configurazione. Poiché abbiamo spring-boot-starter-test nel nostro classpath, possiamo facilmente sfruttare le utilità di test di primavera.

Per prima cosa, creiamo lo scheletro della nostra classe AppControllerIntegrationTest :

@RunWith(SpringRunner.class) @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT) public class AppControllerIntegrationTest { @LocalServerPort private int port; private String uri; @PostConstruct public void init() { uri = "//localhost:" + port; } @MockBean AppService appService; //test cases }

In questo test JUnit, abbiamo annotato la nostra classe con un paio di annotazioni specifiche di Spring che fanno girare l'applicazione localmente in una porta disponibile casuale. In @PostConstruct , abbiamo acquisito l'URI completo su cui effettueremo le chiamate REST.

Abbiamo anche usato @MockBean su AppService , poiché dobbiamo simulare le chiamate al metodo su questa classe.

3. Convalida della risposta JSON

JSON è il formato più comune utilizzato nelle API REST per lo scambio di dati. Le risposte possono essere costituite da un singolo oggetto JSON o da una matrice di oggetti JSON. Vedremo entrambi in questa sezione.

3.1. Oggetto JSON singolo

Supponiamo di dover testare l' endpoint / movie / {id} , che restituisce un oggetto JSON del film se viene trovato l' id .

Ci prendiamo in giro AppService chiamate per restituire alcuni dati finti utilizzando il framework Mockito:

@Test public void givenMovieId_whenMakingGetRequestToMovieEndpoint_thenReturnMovie() { Movie testMovie = new Movie(1, "movie1", "summary1"); when(appService.findMovie(1)).thenReturn(testMovie); get(uri + "/movie/" + testMovie.getId()).then() .assertThat() .statusCode(HttpStatus.OK.value()) .body("id", equalTo(testMovie.getId())) .body("name", equalTo(testMovie.getName())) .body("synopsis", notNullValue()); }

Sopra, abbiamo prima deriso la chiamata appService.findMovie (1) per restituire un oggetto. Quindi, abbiamo costruito il nostro URL REST nel metodo get () fornito da REST-assicurato per effettuare richieste GET. Infine, abbiamo fatto quattro affermazioni.

Per prima cosa, abbiamo controllato il codice di stato della risposta e poi gli elementi del corpo . Stiamo usando Hamcrest per affermare il valore atteso.

Si noti inoltre che se la risposta JSON è nidificata, è possibile testare una chiave nidificata utilizzando l' operatore punto come "key1.key2.key3" .

3.2. Estrazione della risposta JSON dopo la convalida

In alcuni casi, potrebbe essere necessario estrarre la risposta dopo la convalida, per eseguire operazioni aggiuntive su di essa.

Possiamo estrarre la risposta JSON a una classe, utilizzando il metodo extract () :

Movie result = get(uri + "/movie/" + testMovie.getId()).then() .assertThat() .statusCode(HttpStatus.OK.value()) .extract() .as(Movie.class); assertThat(result).isEqualTo(testMovie);

In questo esempio, abbiamo ordinato a REST-assicurato di estrarre la risposta JSON a un oggetto Movie e quindi affermare sull'oggetto estratto.

Possiamo anche estrarre l'intera risposta a una stringa, utilizzando l' API extract (). AsString () :

String responseString = get(uri + "/movie/" + testMovie.getId()).then() .assertThat() .statusCode(HttpStatus.OK.value()) .extract() .asString(); assertThat(responseString).isNotEmpty();

Infine, possiamo anche estrarre un campo particolare dal JSON della risposta .

Diamo un'occhiata a un test per un'API POST che prevede un corpo JSON del film e restituirà lo stesso se inserito correttamente:

@Test public void givenMovie_whenMakingPostRequestToMovieEndpoint_thenCorrect() { Map request = new HashMap(); request.put("id", "11"); request.put("name", "movie1"); request.put("synopsis", "summary1"); int movieId = given().contentType("application/json") .body(request) .when() .post(uri + "/movie") .then() .assertThat() .statusCode(HttpStatus.CREATED.value()) .extract() .path("id"); assertThat(movieId).isEqualTo(11); }

Sopra, abbiamo prima creato l'oggetto richiesta che dobbiamo POST. Abbiamo quindi estratto il campo id dalla risposta JSON restituita utilizzando il metodo path () .

3.3. JSON Array

Possiamo anche verificare la risposta se è un array JSON:

@Test public void whenCallingMoviesEndpoint_thenReturnAllMovies() { Set movieSet = new HashSet(); movieSet.add(new Movie(1, "movie1", "summary1")); movieSet.add(new Movie(2, "movie2", "summary2")); when(appService.getAll()).thenReturn(movieSet); get(uri + "/movies").then() .statusCode(HttpStatus.OK.value()) .assertThat() .body("size()", is(2)); }

Di nuovo abbiamo prima deriso appService.getAll () con alcuni dati e fatto una richiesta al nostro endpoint. Abbiamo quindi affermato lo statusCode e la dimensione del nostro array di risposta.

Anche questa operazione può essere eseguita tramite estrazione:

Movie[] movies = get(uri + "/movies").then() .statusCode(200) .extract() .as(Movie[].class); assertThat(movies.length).isEqualTo(2);

4. Convalida di intestazioni e cookie

Possiamo verificare un'intestazione o un cookie della risposta utilizzando metodi con lo stesso nome:

@Test public void whenCallingWelcomeEndpoint_thenCorrect() { get(uri + "/welcome").then() .assertThat() .header("sessionId", notNullValue()) .cookie("token", notNullValue()); }

Possiamo anche estrarre le intestazioni e i cookie individualmente:

Response response = get(uri + "/welcome"); String headerName = response.getHeader("sessionId"); String cookieValue = response.getCookie("token"); assertThat(headerName).isNotBlank(); assertThat(cookieValue).isNotBlank();

5. Convalida dei file

Se la nostra API REST restituisce un file, possiamo utilizzare il metodo asByteArray () per estrarre la risposta:

File file = new ClassPathResource("test.txt").getFile(); long fileSize = file.length(); when(appService.getFile(1)).thenReturn(file); byte[] result = get(uri + "/download/1").asByteArray(); assertThat(result.length).isEqualTo(fileSize);

Qui, abbiamo prima deriso appService.getFile (1) per restituire un file di testo che è presente nel nostro percorso src / test / resources . Abbiamo quindi effettuato una chiamata al nostro endpoint ed estratto la risposta in un byte [] , che abbiamo quindi affermato di avere il valore atteso.

6. Conclusione

In questo tutorial, abbiamo esaminato diversi modi per acquisire e convalidare le risposte dalle nostre API REST utilizzando REST-assicurato.

Come al solito, il codice in questo articolo è disponibile su Github.

REST fondo

Ho appena annunciato il nuovo corso Learn Spring , incentrato sui fondamenti di Spring 5 e Spring Boot 2:

>> SCOPRI IL CORSO