Abrufen und Überprüfen von Antwortdaten mit REST-Sicherheit

REST Top

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs

1. Übersicht

In diesem Lernprogramm wird erläutert, wie Sie REST-Services mit REST-Assured testen, wobei der Schwerpunkt auf der Erfassung und Validierung der Antwortdaten aus unseren REST-APIs liegt .

2. Setup für die Testklasse

In früheren Tutorials haben wir uns mit REST-Assured im Allgemeinen befasst und gezeigt, wie Anforderungsheader, Cookies und Parameter bearbeitet werden.

Aufbauend auf diesem vorhandenen Setup haben wir einen einfachen REST-Controller, AppController , hinzugefügt , der intern einen Dienst namens AppService aufruft . Wir werden diese Klassen in unseren Testbeispielen verwenden.

Um unsere Testklasse zu erstellen, müssen wir etwas mehr Einstellungen vornehmen. Da wir in unserem Klassenpfad einen Spring-Boot-Starter-Test haben, können wir die Spring-Test-Dienstprogramme problemlos nutzen.

Erstellen wir zunächst das Grundgerüst unserer AppControllerIntegrationTest- Klasse:

@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 diesem JUnit-Test haben wir unsere Klasse mit einigen spring-spezifischen Anmerkungen versehen, die die Anwendung lokal in einem zufällig verfügbaren Port hochfahren. In @PostConstruct haben wir den vollständigen URI erfasst, für den wir REST-Aufrufe durchführen werden.

Wir haben auch @MockBean für AppService verwendet , da wir Methodenaufrufe für diese Klasse verspotten müssen.

3. Überprüfen der JSON-Antwort

JSON ist das am häufigsten verwendete Format in REST-APIs zum Datenaustausch. Antworten können aus einem einzelnen JSON-Objekt oder einem Array von JSON-Objekten bestehen. Wir werden uns beide in diesem Abschnitt ansehen.

3.1. Einzelnes JSON-Objekt

Angenommen, wir müssen den Endpunkt / movie / {id} testen , der ein Movie JSON-Objekt zurückgibt, wenn die ID gefunden wird.

Wir werden AppService- Aufrufe verspotten , um einige Scheindaten mithilfe des Mockito-Frameworks zurückzugeben:

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

Oben haben wir zuerst den Aufruf von appService.findMovie (1) verspottet , um ein Objekt zurückzugeben. Anschließend haben wir unsere REST-URL in der von REST-versichert bereitgestellten get () -Methode für GET-Anforderungen erstellt. Schließlich haben wir vier Aussagen gemacht.

Zuerst haben wir den Antwortstatuscode und dann die Body- Elemente überprüft . Wir verwenden Hamcrest, um den erwarteten Wert zu bestätigen.

Beachten Sie auch , dass , wenn die Antwort JSON verschachtelt ist, wir einen verschachtelten Schlüssel unter Verwendung des testen können Punkt Operator wie „key1.key2.key3“ .

3.2. Extrahieren der JSON-Antwort nach der Validierung

In einigen Fällen müssen wir die Antwort möglicherweise nach der Validierung extrahieren, um zusätzliche Operationen daran auszuführen.

Wir können die JSON-Antwort auf eine Klasse mithilfe der extract () -Methode extrahieren :

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

In diesem Beispiel haben wir REST-versichert angewiesen, die JSON-Antwort auf ein Movie- Objekt zu extrahieren und dann auf dem extrahierten Objekt zu bestätigen.

Wir können auch die gesamte Antwort auf einen String mit der API extract (). AsString () extrahieren :

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

Schließlich können wir auch ein bestimmtes Feld aus dem Antwort-JSON extrahieren .

Schauen wir uns einen Test für eine POST-API an, die einen Movie JSON-Body erwartet und bei erfolgreicher Einfügung denselben zurückgibt:

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

Above, we first made the request object that we need to POST. We then extracted the id field from the returned JSON response using the path() method.

3.3. JSON Array

We can also verify the response if it's a JSON array:

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

We again first mocked the appService.getAll() with some data and made a request to our endpoint. We then asserted the statusCode and size of our response array.

This again can be done via extraction:

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

4. Validating Headers and Cookies

We can verify a header or cookie of the response using methods with the same name:

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

We can also extract the headers and cookies individually:

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

5. Validating Files

Wenn unsere REST-API eine Datei zurückgibt, können wir die Antwort mit der asByteArray () -Methode extrahieren:

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

Hier haben wir zuerst appService.getFile (1) verspottet , um eine Textdatei zurückzugeben, die in unserem Pfad src / test / resources vorhanden ist . Wir haben dann unseren Endpunkt aufgerufen und die Antwort in ein Byte [] extrahiert , von dem wir dann behaupteten, dass es den erwarteten Wert hat.

6. Fazit

In diesem Tutorial haben wir verschiedene Möglichkeiten untersucht, um Antworten von unseren REST-APIs mithilfe von REST-Assured zu erfassen und zu validieren.

Wie üblich ist der Code in diesem Artikel über Github verfügbar.

REST unten

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs