Assuré REST: Conseils utiles

Dans cet article, j'ai rassemblé quelques conseils utiles sur l'utilisation de REST-Guaranteed, l'une des bibliothèques Java les plus courantes pour automatiser les tests d'API REST.

Tous les exemples sont essentiels, ils sont collectés à partir de ma pratique de la révision de code dans plus de 50 projets avec des tests automatiques.

Amenez les points d'extrémité à un endroit séparé

Il semblerait que cela soit évident. Mais non, assez souvent, vous devez voir du code avec des points de terminaison codés en dur dans la demande.

Il est préférable de placer les points finaux dans les constantes statiques de la classe finale. En même temps, il faut éviter l '«interface constante» contre-modèle - c'est une mauvaise pratique.

N'oubliez pas que REST-assure vous permet de faire des paramètres de chemin, par exemple:

public final class EndPoints { public static final String users = "/users/{id}"; ... } given().pathParams("id", someId).get(EndPoints.users)...; //   given().get(EndPoints.users, someId).... 

De plus, si dans de nombreuses requêtes vous utilisez le même chemin de base, il sera judicieux de le mettre dans une constante d'hôtel et de le passer à basePath, par exemple:

 //   url  http://host:port/appname/rest/someEndpoints private static final basePath = "/appname/rest/"; .. //       , //      : RestAssured.basePath = basePath; //     : given().basePath(basePath)... //    ,     

Il en va de même pour l'hôte et le port de l'application testée.

ContentType / Accepter

Ces en-têtes sont utilisés dans presque toutes les requêtes HTTP. Les auteurs assurés par REST, réalisant cela, ont permis de les installer en appelant des méthodes spéciales:

 //   : given().header("content-type", "application/json").header("accept", "application/json")...; //   : given().contentType(ContentType.JSON).accept(ContentType.JSON)...; 

Il est recommandé de définir ces en-têtes dans une spécification ou globalement. Cela augmentera la lisibilité de votre code.

StatusCode, etc.

REST-assure fournit une syntaxe pratique pour vérifier chaque composant de la réponse HTTP, mais dans la pratique, vous continuez à rencontrer un code similaire:

 //   : Response response = given()...when().get(someEndpoint); Assert.assertEquals(200, response.then().extract().statusCode()); //   : given()...when().get(someEndpoint).then().statusCode(200); 

Utiliser les spécifications

La duplication de code est mauvaise. Utilisez les spécifications pour réduire la duplication. Dans REST-Guaranteed, vous pouvez créer des spécifications pour la demande et la réponse. Dans la spécification de la demande, nous mettons tout ce qui peut être dupliqué dans les demandes.

 RequestSpecification requestSpec = new RequestSpecBuilder() .setBaseUri("http://localhost") .setPort(8080) .setAccept(ContentType.JSON) .setContentType(ContentType.ANY) ... .log(LogDetail.ALL) .build(); //       : RestAssured.requestSpecification = requestSpec; //   : given().spec(requestSpec)...when().get(someEndpoint); 

Dans la spécification de la réponse, nous effectuons tous les contrôles qui sont dupliqués de demande en demande.

 ResponseSpecification responseSpec = new ResponseSpecBuilder() .expectStatusCode(200) .expectBody(containsString("success")) .build(); //       : RestAssured.responseSpecification = responseSpec; //   : given()...when().get(someEndpoint).then().spec(responseSpec)...; 

Vous pouvez créer plusieurs spécifications pour différents types de demandes / réponses et les utiliser dans la bonne situation.

N'écrivez pas vos béquilles pour transformer des objets

Vous ne devez pas convertir vos POJO en JSON à l'aide de Jackson ObjectMapper, puis transférer la chaîne résultante vers le corps de la demande. REST-assure fait un excellent travail de cela. Pour cela, le même Jackson ou Gson est utilisé, selon ce qui se trouve dans le chemin de classe. JAXB est utilisé pour convertir en XML. Le format d'origine est déterminé automatiquement par la valeur de Content-Type.

 given().contentType(ContentType.JSON).body(somePojo) .when().post(EndPoints.add) .then() .statusCode(201); //        : SomePojo pojo = given(). .when().get(EndPoints.get) .then().extract().body().as(SomePojo.class); 

De plus, REST-assure fait un excellent travail de conversion de HashMap en JSON et vice versa.

Exploitez la puissance de Groovy

La bibliothèque assurée par REST elle-même est écrite en Groovy et vous permet d'appliquer diverses méthodes de Groovy à la réponse JSON / XML reçue. Par exemple:

 //  find, findAll         ,  collect       . //  it         Map<String, ?> map = get(EndPoints.anyendpoint).path("rootelement.find { it.title =~ 'anythingRegExp'}"); //     ,     Map<String, ?> map = get(EndPoints.anyendpoint).path("rootelement.findAll { element -> element.title.length() > 4 }"); //     sum, max, min     ,        String expensiveCar = get(EndPoints.cars).path("cars.find { it.title == 'Toyota Motor Corporation'}.models.max { it.averagePrice }.title"); 

L'utilisation de méthodes de Groovy peut réduire considérablement la quantité de code que vous écrivez pour trouver la valeur requise dans la réponse.

C'est tout, si vous avez plus de conseils et d'exemples, écrivez-les dans les commentaires.