TOC

Introduction à MockServer

Introduction à MockServer

1. Vue d'ensemble

MockServer est un outil de simulation / stubbing d'API HTTP externes.

2. Dépendances Maven

Pour utiliserMockServer dans notre application, nous devons ajouter deux dépendances: 


    org.mock-server
    mockserver-netty
    3.10.8


    org.mock-server
    mockserver-client-java
    3.10.8

La dernière version des dépendances est disponible enmockserver-netty etmockserver-client.

3. FonctionnalitéMockServer

En termes simples, l'outil peut:

  • générer et renvoyer des réponses fixes

  • transférer une demande vers un autre serveur

  • exécuter des callbacks

  • vérifier une demande

4. Comment exécuterMockServer

Nous pouvons démarrer le serveur de différentes manières - explorons certaines de ces méthodes.

4.1. Lancement via Maven Plugin

Cela lancera le serveur pendant la phaseprocess-test-class et s'arrêtera à la phaseverify: 


    org.mock-server
    mockserver-maven-plugin
    3.10.8
    
        1080
        1090
        DEBUG
        org.mockserver.maven.ExampleInitializationClass
    
    
        
            process-test-classes
            process-test-classes
            
                start
            
        
        
            verify
            verify
            
                stop

4.2. Lancement via l'API Java

Nous pouvons utiliser l'API Java destartClientAndServer() pour démarrer le serveur. En règle générale, nous démarrons un serveur avant d'exécuter tous les tests: 

public class TestMockServer {

    private ClientAndServer mockServer;

    @BeforeClass
    public void startServer() {
        mockServer = startClientAndServer(1080);
    }

    @AfterClass
    public void stopServer() {
        mockServer.stop();
    }

    // ...
}

5. Clients fictifs

L'APIMockServerClient est utilisée pour fournir une capacité de connexion auxMockServer.. Elle modélise les demandes et les réponses correspondantes du serveur.

Il supporte plusieurs opérations:

5.1. Créer des attentes avec des réponses simulées

Les attentes sont un mécanisme par lequel nous simulons la demande d'un client et la réponse résultante de MockServer.

Pour créer une attente, nous devons définir un gestionnaire de requêtes et une réponse à renvoyer.

Les demandes peuvent être associées à l'aide de:

  • chemin - chemin de l'URL

  • query string - Paramètres d'URL

  • en-têtes - demande des en-têtes

  • cookies - cookies côté client

  • body - Corps de la requête POST avec XPATH, JSON, schéma JSON, expression régulière, texte exact correspondant ou paramètres du corps

Tous les paramètres ci-dessus peuvent être spécifiés en utilisant du texte brut ou des expressions régulières.

Et une action de réponse contiendra:

  • codes de statut - codes de statut HTTP valides, par exemple. 200, 400 etc.

  • body - c'est la séquence d'octets contenant n'importe quel contenu

  • en-têtes - en-têtes de réponse avec nom et une ou plusieurs valeurs

  • cookies - cookies de réponse avec nom et une ou plusieurs valeurs

Voyons comment nous pouvonscreate an expectation: 

public class TestMockServer {
    private void createExpectationForInvalidAuth() {
        new MockServerClient("127.0.0.1", 1080)
          .when(
            request()
              .withMethod("POST")
              .withPath("/validate")
              .withHeader("\"Content-type\", \"application/json\"")
              .withBody(exact("{username: 'foo', password: 'bar'}")),
              exactly(1))
                .respond(
                  response()
                    .withStatusCode(401)
                    .withHeaders(
                      new Header("Content-Type", "application/json; charset=utf-8"),
                      new Header("Cache-Control", "public, max-age=86400"))
                    .withBody("{ message: 'incorrect username and password combination' }")
                    .withDelay(TimeUnit.SECONDS,1)
                );
    }
    // ...
}

Ici, nous stubbing une requêtePOST au serveur. Et nous avons spécifié combien de fois nous devons faire cette demande en utilisant l'appel deexactly(1).

À la réception de cette demande, nous avons simulé une réponse avec les champs tels que le code d'état, les en-têtes et le corps de la réponse.

5.2. Transférer une demande

Une attente peut être configurée pour transmettre la demande. Quelques paramètres peuvent décrire l'action suivante:

  • host - l'hôte vers lequel transférer par ex. www.example.com

  • port - le port où la demande doit être transférée, le port par défaut est 80

  • scheme - protocole à utiliser, par ex. HTTP ou HTTPS

Voyons un exemple de demande de transfert: 

private void createExpectationForForward(){
    new MockServerClient("127.0.0.1", 1080)
      .when(
        request()
          .withMethod("GET")
          .withPath("/index.html"),
          exactly(1))
        .forward(
          forward()
            .withHost("www.mock-server.com")
            .withPort(80)
            .withScheme(HttpForward.Scheme.HTTP)
           );
}

Dans ce cas, nous avons simulé une requête qui frappera exactement le serveur simulé, puis transmise à un autre serveur. La méthode externeforward() spécifie l'action de transfert et l'appel de la méthode interneforward() aide à construire l'URL et à transmettre la requête.

5.3. Exécution d'un rappel

L'action de rappel deThe server can be set to execute a callback when receiving a particular request. peut définir la classe de rappel qui implémente l'interface deorg.mockserver.mock.action.ExpectationCallback. Il devrait avoir le constructeur par défaut et devrait être sur le classpath.

Voyons un exemple d’attente avec un rappel: 

private void createExpectationForCallBack() {
    mockServer
      .when(
        request().withPath("/callback"))
        .callback(
          callback()
            .withCallbackClass("com.example.mock.server.TestExpectationCallback")
        );
}

Ici, lecallback() externe spécifie l'action de rappel et la méthodecallback() interne spécifie l'instance de la classe de méthode de rappel.

Dans ce cas, lorsque MockServer reçoit une requête avec/callback,, la méthode de gestion de rappel implémentée dans la classe spécifiée sera exécutée: 

public class TestExpectationCallback implements ExpectationCallback {

    public HttpResponse handle(HttpRequest httpRequest) {
        if (httpRequest.getPath().getValue().endsWith("/callback")) {
            return httpResponse;
        } else {
            return notFoundResponse();
        }
    }

    public static HttpResponse httpResponse = response()
      .withStatusCode(200);
}

5.4. Vérification des demandes

MockServerClient a la capacité de vérifier si le système testé a envoyé une requête: 

private void verifyPostRequest() {
    new MockServerClient("localhost", 1080).verify(
      request()
        .withMethod("POST")
        .withPath("/validate")
        .withBody(exact("{username: 'foo', password: 'bar'}")),
        VerificationTimes.exactly(1)
    );
}

Ici, la classeorg.mockserver.verify.VerificationTimes est utilisée pour spécifier le nombre de fois que le serveur simulé doit correspondre à la demande.

6. Conclusion

Dans cet article rapide, nous avons exploré différentes fonctions du MockServer. Nous avons également exploré les différentes API fournies et leur utilisation pour tester des systèmes complexes.

Comme toujours, le code complet de cet article est disponibleover on GitHub.

Related