Evoluciona tus tests de integración con Mock Server

¿Qué es Mock Server?

Mock Server es una herramienta versátil en la que es posible apoyarse a la hora de probar integraciones contra servicios HTTP. Es especialmente útil para pruebas de integración. Con Mock Server podemos lanzar un servidor HTTP dentro de nuestra suite de tests y definir cómo debe comportarse ante una petición concreta de la aplicación cliente.

Además de esto, Mock Server también nos va a permitir comprobar que el cliente está ejecutando las peticiones esperadas dado un flujo de ejecución.

¿En qué escenarios es útil Mock Server?

Desarrollo API First: Si estamos usando la metodología de desarrollo API First, puede resultarnos útil usar Mock Server para tener rápidamente una aplicación Backend como la que deseamos contra la que integrarnos.
Aislamiento: Las pruebas de integración estarán completamente aisladas de un entorno de pre-producción o integración. Esto implica dos beneficios adicionales. Añade reproducibilidad a nuestras pruebas y también simplifica la puesta en marcha de éstas eliminando dependencias externas.
Velocidad de ejecución: Las pruebas se ejecutarán más rápido al no depender de la red ni de servicios externos.

Desplegando Mock Server como un contenedor docker

Mock Server como tal puede ser desplegado como una aplicación Java en un contenedor Docker. Esto podemos conseguirlo con este docker-compose:

services:
  mockServer:
    image: mockserver/mockserver:5.14.0
    ports:
      - 12345:1080
    environment:
      MOCKSERVER_WATCH_INITIALIZATION_JSON: "true"
      MOCKSERVER_PROPERTY_FILE: /config/mockserver.properties
      MOCKSERVER_INITIALIZATION_JSON_PATH: /config/initializerJson.json
    volumes:
      - type: bind
        source: .
        target: /config

Lanzando este docker-compose con el comando docker-compose up se creará un contenedor docker al que podremos acceder en la URL http://localhost:12345.

Para definir el comportamiento esperado del server externo HTTP tenemos dos opciones. O bien usar la API REST de Mock Server o bien usar un fichero JSON de inicialización.

Si estás integrando un servicio y conoces las respuestas esperadas ante una entrada o quieres probar escenarios especificos puedes definir distintos request matchers, como serían:

Usar el path de la petición HTTP.
Usar un matcher con el cuerpo de la petición HTTP esperando un JSON.
Usar un matcher con el cuerpo de la petición HTTP coincidiendo con una expresión regular.
Usar un matcher por las cabeceras de la petición HTTP.

Si quieres entrar en más detalles te recomiendo que le eches un ojo a este repositorio en Github donde hay un ejemplo de mock server desplegado con Docker. Puedes descargar el repositorio, y desplegarlo con docker-compose up. Una vez el contenedor docker esté listo accede a http://localhost:12345/mockserver/dashboard para ver las expectations creadas y el estado de Mock Server.

MockServer Dashboard

Pruebas de integración en Java con Mock Server

Instalación y configuración

Para comenzar a usar Mock Server en tu proyecto Java, será necesario que añadas las dependencias a los artefactos necesarios. Si usas Gradle, agrega las siguientes línea a tu archivo build.gradle:

testImplementation 'org.mock-server:mockserver-netty:5.11.2'
testImplementation 'org.mock-server:mockserver-client-java:5.11.2'

Ejemplo básico

Veamos un caso de uso de ejemplo, una librería que usaremos como conector contra una API REST para gestionar la reserva de libros. La librería contará con un método para poder recuperar los libros disponibles y un método para poder reservar un ejemplar del libro. Usando mock server podemos mockear un servidor HTTP lanzándolo directamente desde nuestros tests. Para poder inicializar simplemente hay que invocar el método ClientAndServer.startClientAndServer(<port>) antes de cada uno de los tests.

class LibraryClientTestImpl {

    private static final int DEFAULT_PORT = 8181;

    private final LibraryClient libraryClient = new LibraryClientImpl(
        new LibraryClientConfig()
        .setBaseUrl("http://localhost:" + DEFAULT_PORT)
        .setTimeout(1000)
    );

    private ClientAndServer clientAndServer;

    @BeforeEach
    void setUp() {
        // Inicia un mockserver
        clientAndServer = ClientAndServer.startClientAndServer(DEFAULT_PORT);
    }

    @AfterEach
    void tearDown() {
        // Paramos el mockserver
        clientAndServer.stop();
    }

    @Test
    void testGetBooks() {

        final String responseBody = "[{"
          + " \"isbn\": \"9781593279509\", "
          + " \"title\":\"Eloquent Javascript\", "
          + " \"author\":\"Marijin Haverbeke\""
          + "}, {"
          + " \"isbn\": \"9781801072977\", "
          + " \"title\":\"Microservices with Spring Boot and Spring Cloud\", "
          + " \"author\":\"Magnus Larsson\" "
          + "}, {"
          + " \"isbn\": \"9780596004651\", "
          + " \"title\":\"Head First Java\", "
          + " \"author\":\"Kathy Sierra\""
          + "}]";

        // Definimos una expectation para cuando un cliente haga una petición GET contra el endpoint /v1/books
        clientAndServer.when(HttpRequest.request()
            .withMethod("GET")
            .withPath("/v1/books"))
            .respond(
                HttpResponse.response()
                    .withStatusCode(200)
                    .withHeader("Content-Type", "application/json")
                    .withBody(responseBody)
            );

        // Dispara la petición a través del cliente de la librería para probarlo
        List<Book> books = libraryClient.getBooks();
        Book book;

        Assertions.assertEquals(3, books.size());

        // Verifica el primero de los libros

        book = books.get(0);

        Assertions.assertEquals("9781593279509", book.getIsbn());
        Assertions.assertEquals("Eloquent Javascript", book.getTitle());
        Assertions.assertEquals("Marijin Haverbeke", book.getAuthor());

        // Verifica el resto de libros...

        // Verifica que mockserver ha recibido la petición GET /v1/books y la ha recibido una sola vez.

        RequestDefinition[] requests =
          clientAndServer.retrieveRecordedRequests(HttpRequest.request()
            .withMethod("GET")
            .withPath("/v1/books"));
        
        Assertions.assertEquals(1, requests.length);
    }

    // ...

En el test se puede ver como definimos una expectation programáticamente del mismo modo que lo haríamos con un stub. Una vez configurada la expectation, se dispara la ejecución de la petición para obtener los libros disponibles del api y se verifica que los datos recibidos coinciden con los enviados por parte de los resultados introducidos en el stub.

Como un extra, también se valida que se ha realizado la petición contra Mock Server y que ésta se ejecuta una sola vez.

Comprueba la potencia de Mock Server

Mock Server es una herramienta muy útil a la hora de validar escenarios que se puedan dar en tu integración a una API de terceros. Es una herramienta a tener en el radar cuando una aplicación necesite validar que se integra correctamente contra una API de terceros, añadiendo calidad y cobertura de que se cumple con el contrato en cada una de las compilaciones de la aplicación.

Java Spring Boot Docker Pruebas