Introduzione a MockServer

1. Panoramica

MockServer è uno strumento per il mocking / stubbing di API HTTP esterne.

2. Dipendenze di Maven

Per utilizzare MockServer nella nostra applicazione, dobbiamo aggiungere due dipendenze:

 org.mock-server mockserver-netty 3.10.8   org.mock-server mockserver-client-java 3.10.8 

L'ultima versione delle dipendenze è disponibile come mockserver-netty e mockserver-client.

3. Funzionalità MockServer

In poche parole, lo strumento può:

  • generare e restituire risposte fisse
  • inoltrare una richiesta a un altro server
  • eseguire callback
  • verificare una richiesta

4. Come eseguire MockServer

Possiamo avviare il server in diversi modi: esploriamo alcuni di questi metodi.

4.1. Avvio tramite Maven Plugin

Questo avvierà il server durante la fase di process-test-class e si fermerà alla fase di verifica :

 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. Avvio tramite API Java

Possiamo utilizzare l' API Java startClientAndServer () per avviare il server. In genere, avvieremmo un server prima di eseguire tutti i test:

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

5. Mock Clients

L' API MockServerClient viene utilizzata per fornire una capacità di connessione a MockServer. Modella le richieste e le risposte corrispondenti dal server.

Supporta più operazioni:

5.1. Creare aspettative con risposte fittizie

Le aspettative sono un meccanismo con cui prendiamo in giro la richiesta di un client e la risposta risultante da MockServer.

Per creare un'aspettativa, dobbiamo definire un abbinatore di richieste e una risposta che dovrebbe essere restituita.

Le richieste possono essere soddisfatte utilizzando:

  • percorso: percorso dell'URL
  • stringa di query - parametri URL
  • intestazioni - richieste di intestazioni
  • cookie - cookie lato client
  • body - corpo della richiesta POST con XPATH, JSON, schema JSON, espressione regolare, testo normale corrispondente esatto o parametri del corpo

Tutti i parametri di cui sopra possono essere specificati utilizzando testo normale o espressioni regolari.

E un'azione di risposta conterrà:

  • codici di stato - codici di stato HTTP validi, ad esempio 200, 400 ecc.
  • body - è la sequenza di byte che contengono qualsiasi contenuto
  • intestazioni: intestazioni di risposta con nome e uno o più valori
  • cookie - cookie di risposta con nome e uno o più valori

Vediamo come possiamo creare un'aspettativa :

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

In questo caso, stiamo inviando una richiesta POST al server. E abbiamo specificato che quante volte dobbiamo fare questa richiesta usando esattamente (1) call.

Alla ricezione di questa richiesta, abbiamo deriso una risposta con i campi come codice di stato, intestazioni e corpo della risposta.

5.2. Inoltro di una richiesta

È possibile impostare l'aspettativa per inoltrare la richiesta. Alcuni parametri possono descrivere l'azione in avanti:

  • host - l'host da inoltrare, ad esempio, a www.baeldung.com
  • porta - la porta su cui deve essere inoltrata la richiesta, la porta predefinita è 80
  • schema - protocollo da utilizzare, ad esempio, HTTP o HTTPS

Vediamo un esempio di richiesta di inoltro:

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 questo caso, abbiamo deriso una richiesta che colpirà i MockServer esattamente quelli e poi inoltrata a un altro server. Il metodo outer forward () specifica l'azione forward e la chiamata al metodo inner forward () aiuta a costruire l'URL e inoltra la richiesta.

5.3. Esecuzione di una richiamata

Il server può essere impostato per eseguire una richiamata quando riceve una particolare richiesta. L'azione di richiamata può definire una classe di richiamata che implementa l' interfaccia org.mockserver.mock.action.ExpectationCallback . Dovrebbe avere il costruttore predefinito e dovrebbe essere sul classpath.

Vediamo un esempio di aspettativa con una richiamata:

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

Qui il callback () esterno specifica l'azione di callback e il metodo callback () interno specifica l'istanza della classe del metodo di callback.

In questo caso, quando MockServer riceve una richiesta con / callback, verrà eseguito il metodo dell'handle di callback implementato nella classe specificata:

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. Verifica delle richieste

MockServerClient ha la capacità di verificare se il sistema sottoposto a test ha inviato una richiesta:

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

Qui, la classe org.mockserver.verify.VerificationTimes viene utilizzata per specificare il numero di volte in cui il server Mock deve corrispondere alla richiesta.

6. Conclusione

In questo rapido articolo, abbiamo esplorato diverse funzioni del MockServer. Abbiamo anche esplorato le diverse API fornite e come possono essere utilizzate per testare sistemi complessi.

Come sempre, il codice completo di questo articolo è disponibile su GitHub.