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.