Java >> Java Tutorial >  >> Java

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 des WireMock 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() , und trace() Methoden des WireMock -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 des com.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.

Java-Tag