Introdução ao MockServer

1. Visão geral

MockServer é uma ferramenta para simulação / stubbing de APIs HTTP externas.

2. Dependências do Maven

Para usarMockServer em nosso aplicativo, precisamos adicionar duas dependências:


    org.mock-server
    mockserver-netty
    3.10.8


    org.mock-server
    mockserver-client-java
    3.10.8

A última versão das dependências está disponível comomockserver-nettyemockserver-client.

3. Funcionalidade deMockServer

Simplificando, a ferramenta pode:

gerar e retornar respostas fixas
encaminhar uma solicitação para outro servidor
executar retornos de chamada
verificar uma solicitação

4. Como executarMockServer

Podemos iniciar o servidor de algumas maneiras diferentes - vamos explorar alguns desses métodos.

4.1. Lançamento via plug-in Maven

Isso iniciará o servidor durante a faseprocess-test-classe parará na faseverify:


    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. Lançamento via API Java

Podemos usar a API JavastartClientAndServer() para iniciar o servidor. Normalmente, iniciaríamos um servidor antes de executar todos os testes:

public class TestMockServer {

    private ClientAndServer mockServer;

    @BeforeClass
    public void startServer() {
        mockServer = startClientAndServer(1080);
    }

    @AfterClass
    public void stopServer() {
        mockServer.stop();
    }

    // ...
}

5. Clientes Falsos

A APIMockServerClient é usada para fornecer um recurso de conexão com as solicitações de modelosMockServer. e as respostas correspondentes do servidor.

Ele suporta várias operações:

5.1. Criação de expectativas com respostas simuladas

As expectativas são um mecanismo pelo qual simulamos a solicitação de um cliente e a resposta resultante do MockServer.

Para criar uma expectativa, precisamos definir um correspondente de solicitação e uma resposta que deve ser retornada.

Os pedidos podem ser correspondidos usando:

path - caminho da URL
query string - parâmetros de URL
cabeçalhos - solicitar cabeçalhos
cookies - cookies do lado do cliente
body - corpo da solicitação POST com esquema XPATH, JSON, JSON, expressão regular, texto simples ou parâmetros do corpo correspondentes

Todos os parâmetros acima podem ser especificados usando texto simples ou expressões regulares.

E uma ação de resposta conterá:

códigos de status - códigos de status HTTP válidos, por exemplo 200, 400 etc.
body - é a sequência de bytes que contém qualquer conteúdo
cabeçalhos - cabeçalhos de resposta com nome e um ou mais valores
cookies - cookies de resposta com nome e um ou mais valores

Vamos ver como podemoscreate an expectation:

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

Aqui, estamos efetuando o stub de uma solicitaçãoPOST para o servidor. E especificamos quantas vezes precisamos fazer essa solicitação usando a chamadaexactly(1).

Ao receber essa solicitação, zombamos de uma resposta com os campos como código de status, cabeçalhos e corpo da resposta.

5.2. Encaminhando uma solicitação

A expectativa pode ser configurada para encaminhar a solicitação. Alguns parâmetros podem descrever a ação direta:

host - o host para o qual encaminhar, por exemplo www.example.com
port - a porta para onde a solicitação a ser encaminhada, a porta padrão é 80
scheme - protocolo a ser usado, por exemplo HTTP ou HTTPS

Vejamos um exemplo de solicitação de encaminhamento:

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

Nesse caso, zombamos de uma solicitação que atingirá exatamente o MockServer e depois encaminhada para outro servidor. O métodoforward() externo especifica a ação de encaminhamento e a chamada do métodoforward() interno ajuda a construir a URL e encaminha a solicitação.

5.3. Executando um Callback

A ação de retorno de chamadaThe server can be set to execute a callback when receiving a particular request. pode definir a classe de retorno de chamada que implementa a interfaceorg.mockserver.mock.action.ExpectationCallback. Ele deve ter o construtor padrão e deve estar no caminho de classe.

Vejamos um exemplo de expectativa com um retorno de chamada:

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

Aqui, ocallback() externo especifica a ação de retorno de chamada e o métodocallback() interno especifica a instância da classe do método de retorno de chamada.

Nesse caso, quando MockServer recebe uma solicitação com/callback,, o método de manipulação de retorno de chamada implementado na classe especificada será executado:

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. Verificando Solicitações

MockServerClient tem a capacidade de verificar se o sistema em teste enviou uma solicitação:

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

Aqui, a classeorg.mockserver.verify.VerificationTimes é usada para especificar o número de vezes que o Servidor Mock deve corresponder à solicitação.

6. Conclusão

Neste artigo rápido, exploramos diferentes funções do MockServer. Também exploramos as diferentes APIs fornecidas e como elas podem ser usadas para testar sistemas complexos.

Como sempre, o código completo deste artigo está disponívelover on GitHub.

TOC

Introdução ao MockServer