TOC

Einführung in MockServer

Einführung in MockServer

1. Überblick

MockServer ist ein Tool zum Verspotten / Stubben externer HTTP-APIs.

2. Maven-Abhängigkeiten

UmMockServer in unserer Anwendung verwenden zu können, müssen zwei Abhängigkeiten hinzugefügt werden: 


    org.mock-server
    mockserver-netty
    3.10.8


    org.mock-server
    mockserver-client-java
    3.10.8

Die neueste Version der Abhängigkeiten ist alsmockserver-netty undmockserver-client. verfügbar

3. MockServer Funktionalität

Einfach ausgedrückt kann das Tool:

  • Feste Antworten generieren und zurückgeben

  • eine Anfrage an einen anderen Server weiterleiten

  • Rückrufe ausführen

  • Überprüfen Sie eine Anfrage

4. So führen SieMockServer aus

Wir können den Server auf verschiedene Arten starten. Lassen Sie uns einige dieser Methoden untersuchen.

4.1. Starten über das Maven Plugin

Dadurch wird der Server während derprocess-test-class-Phase gestartet und beiverify-Phase gestoppt: 


    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. Starten über Java API

Wir können die Java-API vonstartClientAndServer()verwenden, um den Server zu starten. In der Regel wird ein Server gestartet, bevor alle Tests ausgeführt werden: 

public class TestMockServer {

    private ClientAndServer mockServer;

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

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

    // ...
}

5. Mock Clients

Die API vonMockServerClientwird verwendet, um eine Verbindung zuMockServer. herzustellen. Sie modelliert Anforderungen und die entsprechenden Antworten vom Server.

Es unterstützt mehrere Operationen:

5.1. Erwartungen mit Scheinantworten erstellen

Erwartungen sind ein Mechanismus, mit dem wir die Anfrage von einem Client und die daraus resultierende Antwort von MockServer verspotten.

Um eine Erwartung zu erstellen, müssen Sie einen Anforderungsvergleicher und eine Antwort definieren, die zurückgegeben werden soll.

Anfragen können abgeglichen werden mit:

  • Pfad - URL-Pfad

  • Abfragezeichenfolge - URL-Parameter

  • Header - Header anfordern

  • cookies - clientseitige cookies

  • body - POST-Anforderungshauptteil mit XPATH-, JSON-, JSON-Schema, regulärem Ausdruck, genau übereinstimmendem Klartext oder Hauptteilparametern

Alle oben genannten Parameter können mit normalem Text oder regulären Ausdrücken angegeben werden.

Und eine Antwortaktion enthält:

  • Statuscodes - gültige HTTP-Statuscodes, z. 200, 400 usw.

  • body - das ist die Folge von Bytes, die irgendeinen Inhalt enthalten

  • Header - Antwortheader mit Namen und einem oder mehreren Werten

  • cookies - Antwortcookies mit Namen und einem oder mehreren Werten

Mal sehen, wie wircreate an expectation können: 

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)
                );
    }
    // ...
}

Hier stubben wir einePOST-Anforderung an den Server. Und wir haben angegeben, wie oft wir diese Anfrage mit dem Aufruf vonexactly(1)tellen müssen.

Nach Erhalt dieser Anfrage haben wir eine Antwort mit den Feldern wie Statuscode, Überschriften und Antworttext verspottet.

5.2. Anfrage weiterleiten

Es kann eine Erwartungshaltung eingerichtet werden, um die Anfrage weiterzuleiten. Einige Parameter können die Vorwärtsbewegung beschreiben:

  • host - der Host, an den z. www.example.com

  • port - Der Port, an den die Anforderung weitergeleitet werden soll. Der Standardport ist 80

  • scheme - Protokoll zur Verwendung von z.B. HTTP oder HTTPS

Sehen wir uns ein Beispiel für eine Weiterleitungsanforderung an: 

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

In diesem Fall haben wir eine Anfrage verspottet, die den MockServer genau trifft und dann an einen anderen Server weitergeleitet. Die äußereforward()-Methode gibt die Weiterleitungsaktion an, und der innereforward()-Methodenaufruf hilft beim Erstellen der URL und leitet die Anforderung weiter.

5.3. Rückruf ausführen

Die RückrufaktionThe server can be set to execute a callback when receiving a particular request.kann eine Rückrufklasse definieren, die die Schnittstelle vonorg.mockserver.mock.action.ExpectationCallbackimplementiert. Es sollte den Standardkonstruktor haben und sich im Klassenpfad befinden.

Sehen wir uns ein Beispiel für die Erwartung mit einem Rückruf an: 

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

Hier gibt das äußerecallback() die Rückrufaktion an und die innerecallback()-Methode gibt die Instanz der Rückrufmethodenklasse an.

In diesem Fall wird, wenn MockServer eine Anforderung mit/callback, empfängt, die in der angegebenen Klasse implementierte Callback-Handle-Methode ausgeführt: 

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. Anfragen überprüfen

MockServerClient kann überprüfen, ob das zu testende System eine Anforderung gesendet hat: 

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

Hier wird die Klasseorg.mockserver.verify.VerificationTimesverwendet, um anzugeben, wie oft der Mock Server mit der Anforderung übereinstimmen soll.

6. Fazit

In diesem kurzen Artikel haben wir verschiedene Funktionen des MockServers untersucht. Wir haben auch die verschiedenen APIs untersucht, die bereitgestellt werden, und wie sie zum Testen komplexer Systeme verwendet werden können.

Wie immer ist der vollständige Code für diesen Artikel inover on GitHub. verfügbar

Related