Usando cenários do WireMock

1. Visão geral

Este tutorial rápido mostraráhow we can test a stateful HTTP-based API with WireMock.

Para começar com a biblioteca, dê uma olhada em nosso tutorialIntroduction to WireMock primeiro.

2. Dependências do Maven

Para poder aproveitar as vantagens deWireMock library, precisamos incluir a seguinte dependência no POM:


    com.github.tomakehurst
    wiremock
    2.21.0
    test

3. A API de exemplo que queremos zombar

O conceito de cenários na Wiremock é parahelp simulate the different states of a REST API. Isso nos permite criar testes nos quais a API que estamos usando se comporta de maneira diferente, dependendo do estado em que está.

Para ilustrar isso, vamos dar uma olhada em um exemplo prático: um serviço “Java Tip” que nos dá uma dica diferente sobre Java sempre que solicitamos seu/java-tip ponto de envio.

Se pedirmos uma dica, a receberemos de volta emtext/plain:

"use composition rather than inheritance"

Se ligássemos novamente, receberíamos uma dica diferente.

4. Criando os estados do cenário

Precisamos fazer com que o WireMock crie stubs para o endpoint“/java-tip”. Cada stubs retornará um determinado texto que corresponde a um dos três estados da API simulada:

public class WireMockScenarioExampleIntegrationTest {
    private static final String THIRD_STATE = "third";
    private static final String SECOND_STATE = "second";
    private static final String TIP_01 = "finally block is not called when System.exit()"
      + " is called in the try block";
    private static final String TIP_02 = "keep your code clean";
    private static final String TIP_03 = "use composition rather than inheritance";
    private static final String TEXT_PLAIN = "text/plain";

    static int port = 9999;

    @Rule
    public WireMockRule wireMockRule = new WireMockRule(port);

    @Test
    public void changeStateOnEachCallTest() throws IOException {
        createWireMockStub(Scenario.STARTED, SECOND_STATE, TIP_01);
        createWireMockStub(SECOND_STATE, THIRD_STATE, TIP_02);
        createWireMockStub(THIRD_STATE, Scenario.STARTED, TIP_03);

    }

    private void createWireMockStub(String currentState, String nextState, String responseBody) {
        stubFor(get(urlEqualTo("/java-tip"))
          .inScenario("java tips")
          .whenScenarioStateIs(currentState)
          .willSetStateTo(nextState)
          .willReturn(aResponse()
            .withStatus(200)
            .withHeader("Content-Type", TEXT_PLAIN)
            .withBody(responseBody)));
    }

}

Na classe acima, usamos a classe de regra JUnitWireMockRule do WireMock. Isso configura o servidor WireMock quando o teste JUnit é executado.

Em seguida, usamos o métodostubFor do WireMock para criar os stubs que usaremos mais tarde.

Os principais métodos usados ao criar os stubs são:

whenScenarioStateIs: define em qual estado o cenário precisa estar para que o WireMock use este stub
willSetStateTo: dá o valor que WireMock define o estado após este stub ter sido usado

O estado inicial de qualquer cenário éScenario.STARTED. Portanto, criamos um stub que é usado quando o estado éScenario.STARTED.. Isso move o estado para SECOND_STATE.

Também adicionamos stubs para mover de SECOND_STATE para THIRD_STATE e, finalmente, de THIRD_STATE de volta paraScenario.STARTED.. Portanto, se continuarmos chamando o endpoint/java-tip, o estado muda da seguinte maneira:

Scenario.STARTED → SECOND_STATE → THIRD_STATE → Scenario.STARTED

5. Usando o cenário

Para usar o cenário WireMock, simplesmente fazemos chamadas repetidas para o endpoint/java-tip. Portanto, precisamos modificar nossa classe de teste da seguinte maneira:

    @Test
    public void changeStateOnEachCallTest() throws IOException {
        createWireMockStub(Scenario.STARTED, SECOND_STATE, TIP_01);
        createWireMockStub(SECOND_STATE, THIRD_STATE, TIP_02);
        createWireMockStub(THIRD_STATE, Scenario.STARTED, TIP_03);

        assertEquals(TIP_01, nextTip());
        assertEquals(TIP_02, nextTip());
        assertEquals(TIP_03, nextTip());
        assertEquals(TIP_01, nextTip());
    }

    private String nextTip() throws ClientProtocolException, IOException {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpGet request = new HttpGet(String.format("http://localhost:%s/java-tip", port));
        HttpResponse httpResponse = httpClient.execute(request);
        return firstLineOfResponse(httpResponse);
    }

    private static String firstLineOfResponse(HttpResponse httpResponse) throws IOException {
        try (BufferedReader reader = new BufferedReader(
          new InputStreamReader(httpResponse.getEntity().getContent()))) {
            return reader.readLine();
        }
    }

O métodonextTip() chama o ponto de extremidade/java-tipe retorna a resposta comoString. Então, usamos isso em cada chamadaassertEquals() para verificar se as chamadas realmente fazem o cenário circular entre os diferentes estados.

6. Conclusão

Neste artigo, vimos como usar os cenários do WireMock para zombar de uma API que altera sua resposta dependendo do estado em que está.

Como sempre, todo o código usado neste tutorial está disponívelover on GitHub.

TOC

Usando cenários do WireMock