Einführung in MockServer

1. Übersicht

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

2. Maven-Abhängigkeiten

Um MockServer 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 als mockserver-netty und mockserver-client verfügbar.

3. MockServer- Funktionalität

Einfach ausgedrückt kann das Tool:

  • Feste Antworten generieren und zurückgeben
  • Leiten Sie eine Anfrage an einen anderen Server weiter
  • Rückrufe ausführen
  • Überprüfen Sie eine Anfrage

4. So führen Sie MockServer 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 der Phase der Prozesstestklasse gestartet und in der Überprüfungsphase 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 startClientAndServer () verwenden , um den Server zu starten. Normalerweise starten wir einen Server, bevor wir alle Tests ausführen:

public class TestMockServer { private ClientAndServer mockServer; @BeforeClass public void startServer() { mockServer = startClientAndServer(1080); } @AfterClass public void stopServer() { mockServer.stop(); } // ... }

5. Mock Clients

Die MockServerClient- API wird verwendet, um eine Verbindung zum MockServer herzustellen. Es 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 Anforderung eines Clients und die daraus resultierende Antwort von MockServer verspotten.

Um eine Erwartung zu erstellen, müssen wir einen Anforderungs-Matcher und eine Antwort definieren, die zurückgegeben werden sollen.

Anfragen können abgeglichen werden mit:

  • Pfad - URL-Pfad
  • Abfragezeichenfolge - URL-Parameter
  • Header - Anforderungsheader
  • Cookies - clientseitige Cookies
  • body - POST-Anforderungshauptteil mit XPATH-, JSON-, JSON-Schema, regulärem Ausdruck, genau übereinstimmendem Klartext oder Body-Parametern

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

Und eine Antwortaktion enthält:

  • Statuscodes - gültige HTTP-Statuscodes, z. B. 200, 400 usw.
  • body - Dies ist die Folge von Bytes, die einen beliebigen Inhalt enthalten
  • Header - Antwortheader mit Namen und einem oder mehreren Werten
  • Cookies - Antwort-Cookies mit Namen und einem oder mehreren Werten

Mal sehen, wie wir eine Erwartung schaffen 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 eine POST- Anfrage an den Server. Und wir haben angegeben, wie oft wir diese Anfrage mit genau (1) Aufruf stellen müssen.

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

5.2. Anfrage weiterleiten

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

  • Host - Der Host, an den z. B. www.baeldung.com weitergeleitet werden soll
  • Port - Der Port, an den die Anforderung weitergeleitet werden soll. Der Standardport ist 80
  • Schema - Protokoll zur Verwendung von zB 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 genau die MockServer trifft und dann an einen anderen Server weitergeleitet wird. Die äußere forward () -Methode gibt die Weiterleitungsaktion an, und der innere forward () -Methodenaufruf hilft beim Erstellen der URL und beim Weiterleiten der Anforderung.

5.3. Rückruf ausführen

Der Server kann so eingestellt werden, dass beim Empfang einer bestimmten Anforderung ein Rückruf ausgeführt wird. Die Rückrufaktion kann eine Rückrufklasse definieren, die die Schnittstelle org.mockserver.mock.action.ExpectationCallback implementiert. 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.baeldung.mock.server.TestExpectationCallback") ); }

Hier gibt der äußere Rückruf () die Rückrufaktion und die innere Rückrufmethode () 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 Anfrage 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 Klasse org.mockserver.verify.VerificationTimes verwendet, 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 bereitgestellten APIs und deren Verwendung zum Testen komplexer Systeme untersucht.

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