WireMock-Tutorial:Anfrageabgleich, Teil 1
Dieser Blog-Beitrag bietet eine Einführung in die Anfrageabgleichsunterstützung von WireMock. Nachdem wir diesen Blogbeitrag fertiggestellt haben, werden wir:
- Verstehen Sie, wie der Anfrageabgleich funktioniert.
- Wissen, wie wir die tatsächliche HTTP-Anfragemethode mit der erwarteten Anfragemethode vergleichen können.
- Kann die tatsächliche Anfrage-URL mit der erwarteten Anfrage-URL vergleichen.
Beginnen wir mit einem kurzen Blick auf den Anforderungsabgleich.
Eine sehr schnelle Einführung in die Anforderungszuordnung
Request Matching ermöglicht es uns, Erwartungen für die HTTP-Anfragen zu spezifizieren, die von unserem WireMock-Server empfangen werden. Wir können den Anfrageabgleich für zwei Zwecke verwenden:
- Wir können unseren WireMock-Server so konfigurieren, dass er eine bestimmte HTTP-Antwort zurückgibt, wenn er eine HTTP-Anforderung erhält, die unsere Erwartungen erfüllt.
- Wir können sicherstellen, dass unser WireMock-Server eine HTTP-Anfrage erhält, die unsere Erwartungen erfüllt.
WireMock bietet eine vielseitige Unterstützung zum Festlegen von Erwartungen für die verschiedenen Attribute einer HTTP-Anforderung. Beispielsweise können wir Erwartungen für HTTP-Anforderungsmethoden, Anforderungs-URLs, Cookies, Anforderungsheader, Anforderungsparameter und Anforderungstexte angeben.
Als Nächstes werden wir herausfinden, wie wir Erwartungen für HTTP-Anforderungsmethoden und Anforderungs-URLs angeben können.
Festlegen von Erwartungen für Anfragemethoden und Anfrage-URLs
Bevor wir Erwartungen für die anderen Attribute einer HTTP-Anforderung angeben können, müssen wir die erwartete Anforderungsmethode und die Anforderungs-URL angeben, indem Sie diesen Schritten folgen:
Zuerst , müssen wir die erwartete Anfragemethode mit einer der folgenden Methoden angeben:
- Die
static any()
Methode desWireMock
Klasse ignoriert die Anfragemethode. Mit anderen Worten, wir sollten diese Methode verwenden, wenn uns die Anfragemethode der erwarteten HTTP-Anfrage egal ist. - Der
static delete()
,get()
,options()
,post()
,put()
, undtrace()
Methoden desWireMock
-Klasse erlauben es uns, die erwartete Anfragemethode anzugeben.
Diese Methoden nehmen einen UrlPattern
entgegen Objekt als Methodenparameter und geben einen MappingBuilder
zurück Objekt. Die UrlPattern
-Klasse ermöglicht es uns, die erwartete Anforderungs-URL und den MappingBuilder
anzugeben interface deklariert die Methoden, die es uns ermöglichen, andere Erwartungen für die erwartete HTTP-Anfrage zu spezifizieren.
Zweite haben wir einen neuen UrlPattern
erstellt -Objekt und übergeben Sie dieses Objekt an die Methode, die die erwartete Anforderungsmethode angibt. Wenn wir die erwartete Anforderungs-URL angeben möchten, können wir diese static
verwenden Methoden des WireMock
Klasse:
- Die
anyUrl()
-Methode ignoriert die Anforderungs-URL. Mit anderen Worten, wir sollten diese Methode verwenden, wenn uns die URL der erwarteten HTTP-Anforderung egal ist. - Der
urlEqualTo()
-Methode vergleicht die tatsächliche URL mit der erwarteten URL, die als Methodenparameter angegeben ist. Wenn wir die erwartete URL angeben, müssen wir die vollständige URL verwenden, die die Abfrage- und Fragmentkomponenten enthält. - Der
urlMatching()
method vergleicht die tatsächliche URL mit einem regulären Ausdruck, der als Methodenparameter angegeben ist. Wenn wir die URL-Regex erstellen, müssen wir sicherstellen, dass unsere Regex mit der vollständigen URL übereinstimmt, die die Abfrage- und Fragmentkomponenten enthält. - Die
urlPathEqualTo()
-Methode vergleicht den tatsächlichen URL-Pfad mit dem erwarteten URL-Pfad, der als Methodenparameter angegeben ist. - Die
urlPathMatching()
method vergleicht den tatsächlichen URL-Pfad mit einem regulären Ausdruck, der als Methodenparameter angegeben ist.
Als Nächstes sehen wir uns sechs Beispiele an, die zeigen, wie wir Erwartungen an die HTTP-Anforderungsmethode und die Anforderungs-URL spezifizieren können. Doch bevor wir das tun können, müssen wir noch schnell unsere Testklasse absolvieren.
Unsere Testklasse hat eine Testmethode, die sicherstellt, dass unser WireMock-Server den HTTP-Statuscode 200 zurückgibt, wenn er eine HTTP-Anfrage erhält, die unsere Erwartungen erfüllt. Wir können HTTP-Anfragen mit dem static givenThat()
abbrechen Methode des WireMock
Klasse. Diese Methode benötigt MappingBuilder
Objekt als Methodenparameter und gibt ein StubMapping
zurück Objekt.
Nachdem wir diese Testmethode implementiert haben, sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should return the HTTP status code 200") void shouldReturnHttpStatusCodeOk() { givenThat(null .willReturn(aResponse().withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Fangen wir an.
Beispiel 1:
Wenn wir erwarten, dass unser WireMock-Server eine HTTP-Anfrage erhält, die jede Anfragemethode und Anfrage-URL verwenden kann, müssen wir unsere Erwartungen mit dem any()
spezifizieren und anyUrl()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should ignore the request method and URL") void shouldIgnoreRequestMethod() { givenThat(any(anyUrl()).willReturn(aResponse() .withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Beispiel 2:
Wenn wir erwarten, dass unser WireMock-Server einen GET
empfängt Anfrage an eine beliebige Anfrage-URL, müssen wir unsere Erwartungen mit dem get()
spezifizieren und anyUrl()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should compare the actual request method with the expected method") void shouldCompareActualRequestMethodWithExpectedRequestMethod() { givenThat(get(anyUrl()).willReturn(aResponse() .withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Beispiel 3:
Wenn wir erwarten, dass unser WireMock-Server einen GET
empfängt Anfrage an die URL:'/api/message?id=1', müssen wir unsere Erwartungen mit dem get()
spezifizieren und urlEqualTo()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should compare the actual URL with the exact expected URL") void shouldCompareActualUrlWithExactExpectedUrl() { givenThat(get(urlEqualTo("/api/message?id=1")).willReturn(aResponse() .withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Beispiel 4:
Wenn wir erwarten, dass unser WireMock-Server einen GET
empfängt Anfrage an eine URL, die mit der Zeichenfolge „/api/“ beginnt und mit der Zeichenfolge „?id=1“ endet, müssen wir unsere Erwartungen mit dem get()
spezifizieren und urlMatching()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should compare the actual URL with the expected URL regex") void shouldCompareActualUrlWithExpectedUrlRegex() { givenThat(get(urlMatching("/api/([a-z]*)\\?id=1")) .willReturn(aResponse().withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Beispiel 5:
Wenn wir erwarten, dass unser WireMock-Server einen GET
empfängt Anfrage an den URL-Pfad:'/api/message', müssen wir unsere Erwartungen mit dem get()
spezifizieren und urlPathEqualTo()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should compare the actual URL path with the expected URL path") void shouldCompareActualUrlWithExactExpectedUrl() { givenThat(get(urlPathEqualTo("/api/message")) .willReturn(aResponse().withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity( serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Beispiel 6:
Wenn wir erwarten, dass unser WireMock-Server einen GET
empfängt Anfrage an einen URL-Pfad, der mit der Zeichenfolge „/api/“ beginnt, müssen wir unsere Erwartungen mit dem get()
spezifizieren und urlPathMatching()
Methoden des WireMock
Klasse.
Nachdem wir den erforderlichen MappingBuilder
erstellt haben Objekt sieht der Quellcode unserer Testklasse wie folgt aus:
import com.github.tomakehurst.wiremock.WireMockServer; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import static com.github.tomakehurst.wiremock.client.WireMock.*; import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; import static org.assertj.core.api.Assertions.assertThat; class RequestMatchingTest { private RestTemplate restTemplate; private WireMockServer wireMockServer; @Test @DisplayName("Should compare the actual URL path with the expected path regex") void shouldCompareActualUrlWithExpectedUrlRegex() { givenThat(get(urlPathMatching("/api/([a-z]*)")) .willReturn(aResponse().withStatus(200)) ); String serverUrl = buildApiMethodUrl(1L); ResponseEntity<String> response = restTemplate.getForEntity(serverUrl, String.class ); assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK); } private String buildApiMethodUrl(Long messageId) { return String.format("http://localhost:%d/api/message?id=%d", this.wireMockServer.port(), messageId ); } }
Wir können jetzt unsere Erwartungen für die Anforderungsmethode und die Anforderungs-URL einer HTTP-Anforderung angeben, die von unserem WireMock-Server empfangen wird. Fassen wir zusammen, was wir aus diesem Blogbeitrag gelernt haben.
Zusammenfassung
Dieser Blogbeitrag hat uns sechs Dinge beigebracht:
- Anfrageabgleich ermöglicht es uns, Erwartungen für die HTTP-Anfragen zu spezifizieren, die von unserem WireMock-Server empfangen werden.
- Wir können den Anforderungsabgleich verwenden, wenn wir HTTP-Anforderungen stumpfen und/oder verspotten.
- Wir können Erwartungen für HTTP-Anforderungsmethoden, Anforderungs-URLs, Cookies, Anforderungsheader, Anforderungsparameter und Anforderungstexte angeben.
- Wenn wir Erwartungen für die Attribute einer HTTP-Anfrage spezifizieren, müssen wir den
static
verwenden Fabrikmethoden descom.github.tomakehurst.wiremock.client.WireMock
Klasse. - Wenn wir die erwartete URL angeben, müssen wir die URL-Komponenten weglassen, die der Pfadkomponente vorausgehen.
- Wenn die erwartete HTTP-Anforderung mehrere Anforderungsparameter hat, sollten wir den pfadbasierten Abgleich verwenden, da wir damit unsere Erwartungen so spezifizieren können, dass sie nicht von der Reihenfolge der erwarteten Anforderungsparameter abhängen.