Olá, meu nome é Mauro Guardarini, atuo como pessoa desenvolvedora na Lambda3, e recentemente surgiu a ideia de utilizar Docker para realizar os testes de integração do projeto que estou atuando.

Com o intuito de transmitir um pouco do conhecimento que assimilei nessa jornada, criei esse post que acredito que possa ser útil para outras pessoas que estão em um cenário semelhante.

Mas antes de começarmos, aí vai uma breve introdução sobre testes de integração e Docker, ok? Então vem comigo…

O que é teste de integração ?

De forma breve, um teste de integração, como o próprio nome diz, é aquele que testa a integração entre duas partes do seu sistema.

Por exemplo: os testes que você escreve para a sua Web API, onde seu projeto realiza requisições HTTP, é um teste de integração. Isso quer dizer que você está testando a integração do seu sistema com o sistema externo, que é a API. Tranquilo até aqui? Caso você queira saber ainda mais sobre este assunto, você pode verificar neste link aqui bem legal da Microsoft 🙂

O que é Docker ?

É uma ferramenta projetada para facilitar a criação, implementação e a execução de aplicativos usando containers que são como caixas onde colocamos o software e todas as suas dependências, com o objetivo final de facilitar a sua distribuição.

E é graças a esta ação dos containers que a pessoa desenvolvedora pode ter certeza de que o aplicativo será executado em qualquer outra máquina, independentemente de qualquer configuração personalizada que essa máquina possa ter e que possam diferenciar da máquina usada para desenvolver e testar o código. E se você também quiser saber mais sobre este assunto, basta acessar esse link aqui.

Problemática:

Imagine que você tenha um projeto que seja um Web Api com o ASP.NET Core e seu principal desafio é realizar testes de integração nesse projeto para garantir que, dada uma requisição HTTP ela esteja com o comportamento esperado, isto é, retornando o header, body e status code que você deseja.

Imaginou?

Como criar um ambiente que você possa confiar que todas as dependências que o projeto precisa estão disponíveis sem sofrer influência do local onde o projeto está sendo executado ? Nesse momento o docker entrou na minha vida e encheu ela de alegria.

Solução que eu encontrei com Docker para resolver esta situação:

Com o intuito de tornar o ambiente de execução dos testes mais portável, isto é, sem sofrer impacto do computador onde o projeto foi clonado e evitar aquela famosa frase “Ahhh, mas funciona na minha maquina 🙄”, é que eu resolvi utilizar o Docker.

Dessa forma, encapsulo o ambiente com todas as dependências que é necessário para o projeto ser executado e caso ocorra alguma falha posso “desconsiderar” problemas relacionados ao ambiente e focar no código fonte.

O intuito desse post é focar no uso do Docker, certo? Portanto, abaixo eu demonstro utilizando um projeto desenvolvido em asp.net core que possui uma proposta de teste de integração e está disponível nesse link, você pode clonar o repositório utilizando git, ou realizar download, como preferir.

Dentro desse repositório existem alguns arquivos Docker necessários para preparar o cenário para os nossos testes de integração e são eles:

1. 1. 1. Dockerfile: É um arquivo de texto que contém uma lista de comandos que o daemon do Docker chama durante a criação de uma imagem e será utilizado para criar e publicar o conteúdo do serviço e copiar o conteúdo publicado em um container.
         
      2. Dockerfile.integration: Será utilizado para criar e restaurar o projeto de teste de integração, preparando-o para executar os testes.

         

      3. docker-compose-integration.yml: Será utilizado para manter o serviço ToDo e executar nossos testes de integração consumindo o serviço.
         

Bom, agora que preparamos o cenário, vamos para a parte mais legal 😋 que é executar o projeto. Para isso, vamos utilizar o docker-compose que é uma ferramenta para definir e executar aplicativos Docker com vários containers.

Com o Compose, você usa um arquivo YAML (YAML Ain’t Markup Language) para configurar os serviços do seu aplicativo (no nosso caso o arquivo que estamos utilizando para isso o docker-compose-integration.yml).

Então, com apenas um único comando (sim, isso mesmo), você cria e inicia todos os serviços da sua configuração. Super incrível, né?

docker-compose -f docker-compose-integration.yml up

via GIPHY

Após executar o comando você deve ter uma tela parecida com a que está abaixo que consiste na execução dos comandos que estão no arquivo Dockerfile.

Lembrando que essa instalação só ocorre uma unica vez, ou seja, nas próximas vezes que esse mesmo comando for executado, não será necessário realizar todas as instalações.

Quando o processo de instalação terminar os testes serão executados em uma tela parecida com essa que consta algumas informações entre elas se o teste foi executado, aprovados, falhados e o tempo de execução.

E é isso pessoal! Espero que tenham gostado e que ajude no processo de aprendizado sobre esse mundo maravilhoso que é o Docker. Ah, e claro, se quiser dividir sua experiência com Docker ou tiver alguma dúvida sobre as explicações desse post, deixe seu comentário aqui que eu ficarei muito feliz de responder.