TOC

Explorer le cadre de test de Jersey

Explorer le cadre de test de Jersey

1. Vue d'ensemble

Dans ce tutoriel, nous allons examiner le cadre de test de Jersey et voir comment nous pouvons l’utiliser pour écrire rapidement des tests d’intégration.

Comme nous l'avons déjà vu dans les articles précédents,Jersey is an open source framework for developing RESTful Web Services. Nous pouvons en savoir plus sur Jersey dans notre introduction à la création d'une API avec l'article Jersey et Spring -here.

2. Configuration de l'application

Jersey Test Framework est un outil qui nous aide à vérifier la bonne implémentation de nos composants côté serveur. Comme nous le verrons plus tard,it provides a fast and fuss-free way for writing integration tests et peut très bien gérer la communication avec nos API HTTP.

Likewise, it works almost out-of-the-box and it’s easy to integrate with our Maven-based projects. Le framework est principalement basé sur JUnit, bien qu'il soit possible de l'utiliser avec TestNG, ce qui le rend utilisable dans presque tous les environnements.

Dans la section suivante, nous verrons quelles dépendances nous devons ajouter à notre application pour utiliser le framework.

2.1. Dépendances Maven

Tout d'abord, ajoutons la dépendance principale de Jersey Test Framework à nospom.xml: 


    org.glassfish.jersey.test-framework
    jersey-test-framework-core
    2.27
    test

Comme toujours, nous pouvons obtenir la dernière version deMaven Central.

Presque tous les tests de Jersey utilisent l’usine de conteneurs de tests de facto Grizzly, qu’il faudra également ajouter: 


    org.glassfish.jersey.test-framework.providers
    jersey-test-framework-provider-grizzly2
    2.27
    test

Encore une fois, nous pouvons trouver la dernière version dansMaven Central.

3. Commencer

Dans cette section suivante, nous aborderons les étapes de base nécessaires pour rédiger un test simple.

Nous allons commencer par tester la simple ressourceGreetings sur notre serveur: 

@Path("/greetings")
public class Greetings {

    @GET
    @Path("/hi")
    public String getHiGreeting() {
        return "hi";
    }
}

3.1. Configuration du test

Définissons maintenant notre classe de test: 

public class GreetingsResourceIntegrationTest extends JerseyTest {

    @Override
    protected Application configure() {
        return new ResourceConfig(Greetings.class);
    }
    //...
}

We can see in the above example that to develop a test using the Jersey Test Framework our test needs to subclass JerseyTest.

Ensuite, nous remplaçons la méthodeconfigure qui renvoie une configuration de ressource personnalisée pour notre test et ne contient que la ressourceGreetings. C’est bien entendu la ressource que nous souhaitons tester.

3.2. Rédaction de notre premier test

Commençons par tester une simple requête GET à partir de notre API de message d'accueil: 

@Test
public void givenGetHiGreeting_whenCorrectRequest_thenResponseIsOkAndContainsHi() {
    Response response = target("/greetings/hi").request()
        .get();

    assertEquals("Http Response should be 200: ", Status.OK.getStatusCode(), response.getStatus());
    assertEquals("Http Content-Type should be: ", MediaType.TEXT_HTML, response.getHeaderString(HttpHeaders.CONTENT_TYPE));

    String content = response.readEntity(String.class);
    assertEquals("Content of ressponse is: ", "hi", content);
}

Notez que nous avons un accès complet à la réponse HTTP -so we can do things like checking the status code to make sure the operation was actually successful, or work with the actual body of the response.

Expliquons plus en détail ce que nous faisons dans l'exemple ci-dessus:

  1. Envoyer une requête HTTP GET à "/ greetings / hi"

  2. Vérifiez le code d'état HTTP et les en-têtes de réponse du type de contenu

  3. Tester le contenu de la réponse contient la chaîne "hi"

4. Test de GET pour récupérer des ressources

Maintenant que nous avons vu les étapes de base impliquées dans la création de tests. Testons la simple API Fruit que nous avons introduite dans les excellentsJersey MVC Support article.

4.1. Obtenez du JSON simple

Dans l'exemple ci-dessous, nous travaillons avec le corps de la réponse en tant que chaîne JSON standard: 

@Test
public void givenFruitExists_whenSearching_thenResponseContainsFruit() {
    final String json = target("fruit/search/strawberry").request()
        .get(String.class);
    assertThat(json, containsString("{\"name\":\"strawberry\",\"weight\":20}"));
}

4.2. Obtenir l'entité au lieu de JSON

Nous pouvons également mapper la réponse directement à une classe d'entité Resource - par exemple: 

   @Test
    public void givenFruitExists_whenSearching_thenResponseContainsFruitEntity() {
        final Fruit entity = target("fruit/search/strawberry").request()
            .get(Fruit.class);

        assertEquals("Fruit name: ", "strawberry", entity.getName());
        assertEquals("Fruit weight: ", Integer.valueOf(20), entity.getWeight());
    }

Cette fois, nous spécifions le type Java dans lequel l'entité de réponse sera convertie dans la méthodeget - un objetFruit.

5. Tester POST pour créer des ressources

Afin de créer une nouvelle ressource dans notre API, nous ferons un bon usage des requêtes POST. Dans la section suivante, nous verrons comment tester cette partie de notre API.

5.1. Publier JSON brut

Commençons par publier une chaîne JSON simple pour tester la création d'une nouvelle ressource fruitière: 

@Test
public void givenCreateFruit_whenJsonIsCorrect_thenResponseCodeIsCreated() {
    Response response = target("fruit/created").request()
        .post(Entity.json("{\"name\":\"strawberry\",\"weight\":20}"));

    assertEquals("Http Response should be 201 ", Status.CREATED.getStatusCode(), response.getStatus());
    assertThat(response.readEntity(String.class), containsString("Fruit saved : Fruit [name: strawberry colour: null]"));
}

Dans l'exemple ci-dessus, nous utilisons la méthodepost qui prend un paramètre d'objetEntity. We use the convenient json method to create an entity from the corresponding JSON string.

5.2. Publier l'entité au lieu de JSON

As we’ve already seen with get requests we can also post a Resource entity class directly - par exemple: 

@Test
public void givenCreateFruit_whenFruitIsInvalid_thenResponseCodeIsBadRequest() {
    Fruit fruit = new Fruit("Blueberry", "purple");
    fruit.setWeight(1);

    Response response = target("fruit/create").request(MediaType.APPLICATION_JSON_TYPE)
        .post(Entity.entity(fruit, MediaType.APPLICATION_JSON_TYPE));

    assertEquals("Http Response should be 400 ", 400, response.getStatus());
    assertThat(response.readEntity(String.class), containsString("Fruit weight must be 10 or greater"));
}

Cette fois, nous utilisons la méthodeentity pour publier notre entité Fruit et spécifions également le type de média comme JSON.

5.3. Soumissions de formulaires à l'aide de POST

Dans notre dernier exemple de publication, nous verrons comment tester les soumissions de formulaire via une requête de publication: 

@Test
public void givenCreateFruit_whenFormContainsNullParam_thenResponseCodeIsBadRequest() {
    Form form = new Form();
    form.param("name", "apple");
    form.param("colour", null);

    Response response = target("fruit/create").request(MediaType.APPLICATION_FORM_URLENCODED)
        .post(Entity.form(form));

    assertEquals("Http Response should be 400 ", 400, response.getStatus());
    assertThat(response.readEntity(String.class), containsString("Fruit colour must not be null"));
 }

De même, nous utilisons la classeEntity mais cette fois nous transmettons un formulaire contenant un certain nombre de paramètres à notre demande de publication.

6. Tester d'autres verbes HTTP

Parfois, nous devons tester d’autres terminaux HTTP, tels que PUT et DELETE. This is of course perfectly possible using the Jersey Test Framework.

Voyons un exemple PUT simple: 

@Test
public void givenUpdateFruit_whenFormContainsBadSerialParam_thenResponseCodeIsBadRequest() {
    Form form = new Form();
    form.param("serial", "2345-2345");

    Response response = target("fruit/update").request(MediaType.APPLICATION_FORM_URLENCODED)
        .put(Entity.form(form));

    assertEquals("Http Response should be 400 ", 400, response.getStatus());
    assertThat(response.readEntity(String.class), containsString("Fruit serial number is not valid"));
}

Une fois que nous avons appelé la méthoderequest, nous pouvons invoquer n'importe quelle méthode HTTP sur l'objet de requête actuel.

7. Caractéristiques supplémentaires

Le framework de test Jersey contient un certain nombre de propriétés de configuration supplémentaires qui peuvent aider au débogage et aux tests.

Dans l'exemple suivant, nous verrons comment activer par programmation une fonctionnalité avec un nom donné: 

public class FruitResourceIntegrationTest extends JerseyTest {

    @Override
    protected Application configure() {
        enable(TestProperties.LOG_TRAFFIC);
        enable(TestProperties.DUMP_ENTITY);
        //...

Lorsque nous créons et configurons notre application Jersey sous test. Nous pouvons également activer des propriétés supplémentaires. Dans ce cas, nous activons deux propriétés de journalisation -LOG_TRAFFIC etDUMP_ENTITYwhich will provide useful additional logging and debug information during test runs.

8. Conteneurs pris en charge

Comme nous l'avons déjà mentionné, le conteneur de facto utilisé lors de l'écriture de tests avec le Jersey Test Framework est Grizzly. However, a number of other containers are supported:

  • Conteneur en mémoire

  • HttpServer à partir du JDK Oracle

  • Conteneur simple (org.simpleframework.http

  • Conteneur Jetty (org.eclipse.jetty)

Pour plus d'informations sur la configuration de ces conteneurs, veuillez consulter la documentationhere.

9. Conclusion

Pour résumer, dans ce tutoriel, nous avons exploré le framework de test Jersey. Tout d'abord, nous avons commencé par expliquer comment configurer le cadre de test Jersey, puis nous avons vu comment écrire un test pour une API très simple.

Dans la section suivante, nous avons vu comment écrire des tests pour divers points de terminaison API GET et POST. Enfin, nous avons examiné certaines fonctionnalités supplémentaires et les conteneurs pris en charge par Jersey Test Framework.

Comme toujours, le code source complet de l'article est disponibleover on GitHub.

Related