Testes em .NET: integre seus testes nos pipelines de CI/CD

Pipeline de testes no GitHub Actions - Apresentação

Olá, pessoal! Meu nome é André Bessa e serei seu instrutor nesta jornada!

Audiodescrição: André se descreve como um homem negro, com barba e cabelos rente ao rosto. Veste uma camiseta azul-marinho com a logo da Alura na cor branca. Ao fundo, uma estante com itens decorativos iluminada por tons de azul e verde.

Pré-requisitos

Para aproveitar ao máximo este curso, é altamente recomendável que você tenha concluído os cursos anteriores da formação. É importante ter conhecimentos em C#, orientação a objetos e testes automatizados. Também são essenciais os fundamentos de DevOps, especialmente em integração e entrega contínua.

O que aprenderemos?

Neste curso, você aprenderá a preparar nossa solução para ser entregue em um ambiente de homologação e produção. Isso pode incluir um ambiente de hospedagem personalizada ou plataformas de nuvem como Azure ou AWS.

Também vamos configurar o ambiente para tornar nossos testes de integração mais independentes, criar uma pipeline automatizada que incorpore os testes de unidade e de integração, e estabelecer um fluxo completo de integração e entrega contínua, utilizando ferramentas como GitHub Actions e Azure DevOps.

Continuaremos trabalhando com o projeto Jornada Milhas, que nos acompanha desde o início da formação. Neste curso, o objetivo é entregar a API do Jornada Milhas no Azure, para poder ser consumida por outras aplicações, incluindo testes automatizados no processo.

Para que você tenha uma visão geral do que vamos aprender, esquematizamos algumas etapas. Partiremos do ambiente local, desenvolveremos uma pipeline de CI (Integração Contínua) e CD (Entrega Contínua), e faremos a entrega da nossa API em um ambiente externo, no Azure.

Por que estudar e fazer este curso? Primeiramente, pela garantia da qualidade. É crucial que consigamos executar todos os testes antes de publicar nossa solução. Além disso, alinhamos nossas práticas às do mercado, onde a maioria das empresas implementa pipelines de integração e deploy (CI e CD), integrando os testes no processo. Isso também aumenta nossa produtividade, permitindo que você não precise interromper o desenvolvimento para fazer a entrega da solução em um ambiente externo ou para um cliente.

Além de tudo isso, convido você a aproveitar ao máximo nossa plataforma. Além dos vídeos, temos diversas atividades, um fórum bastante ativo e uma comunidade no Discord. Vamos nessa?

Pipeline de testes no GitHub Actions - Configurando o projeto de testes

Te desejo as boas-vindas a mais um curso da Formação de Testes em .NET!

Neste curso, enfrentaremos o desafio de entregar nossa solução, a Jornada Milhas API, em um ambiente externo, como um ambiente de produção na nuvem, como Azure ou AWS. Para isso, precisamos gerar alguns arquivos para publicação.

Publicação do projeto

Primeiro, em nosso projeto, podemos clicar com o botão direito do mouse em JornadaMilhas.API, no Gerenciador de Soluções à direita, e selecionar "Publicar" para liberar os arquivos necessários para a implantação do projeto. No entanto, estamos focando bastante em testes, então o ideal é rodarmos os testes primeiro para garantir a qualidade do nosso projeto antes de gerar os arquivos para publicação.

Automação com script

Podemos executar todos os testes indo ao Gerenciador de Testes, à esquerda, e executar todos os testes. No entanto, esse processo ainda seria muito manual, pois precisaríamos primeiro executar os testes e depois publicar a API. Podemos melhorar esse fluxo automatizando essas etapas com um script.

Para isso, podemos adicionar um novo item ao nosso projeto, criando um arquivo de script (script.bat). Nele, colocamos os comandos necessários para executar os testes e publicar a API, como dotnet test para os testes de unidade e integração, e dotnet publish para publicar a API.

dotnet test ./test/JornadaMilhas. Unit.Test
dotnet test ./test/JornadaMilhas.Integration.Test.API
dotnet publish ./src/JornadaMilhas.AΡΙ

Execução do script

Após salvar o script, abrimos um terminal e o executamos com .\script.bat. No entanto, percebemos que o teste de integração não foi executado devido a uma dependência do Docker, que precisa estar em execução para que os testes de integração funcionem.

Vamos iniciar novamente os nossos contêineres e executar o script novamente. Ao fazer isso, ele deve rodar os testes de unidade, os testes de integração e, em seguida, gerar os arquivos para publicação.

Introdução às pipelines

Nosso objetivo é criar um processo menos dependente do ambiente local, onde possamos automatizar todas essas etapas: executar os testes, gerar o build e publicar a solução, garantindo que tudo esteja funcionando corretamente antes da implantação.

Essas etapas são conhecidas como pipeline. Vamos trabalhar com ferramentas que permitem criar pipelines automatizadas, que executam essas etapas de forma eficiente e confiável, culminando na implantação em um ambiente externo.

Próximos passos

Uma dessas ferramentas que abordaremos é o GitHub Actions, que utilizaremos nas próximas aulas para configurar nossa pipeline automatizada.

Pipeline de testes no GitHub Actions - Criação do Workflow

Vamos iniciar a nossa jornada para automatizar esta pipeline utilizando o GitHub Actions. Já temos um script que define os passos a serem executados, e agora vamos adaptá-lo para o formato que o GitHub Actions utiliza.

Criação do arquivo YML

Primeiro, vamos abrir o Visual Studio. Temos um script que realiza os testes de unidade, integração e API:

dotnet test ./test/JornadaMilhas. Unit.Test
dotnet test ./test/JornadaMilhas.Integration.Test.API
dotnet publish ./src/JornadaMilhas.AΡΙ

Precisamos criar um arquivo yml dentro da pasta GitHub Actions. Para isso, na pasta no gerenciador de arquivos, vamos copiar o arquivo script.bat, que acabamos de criar, navegar até a pasta .github/workflows e colar esse arquivo. Em seguida, vamos renomeá-lo para script.yml a fim de reaproveitar a lógica.

Feito isso, voltamos ao Visual Studio e abrimos este arquivo script.yml. Nele, vamos comentar as linhas do script original, pois esse não é o formato que o script.yml utiliza no GitHub Actions. Para comentar, basta incluir # no início de cada linha. Não vamos apagá-las para mantê-las como referência.

#dotnet test ./test/JornadaMilhas. Unit.Test
#dotnet test ./test/JornadaMilhas.Integration.Test.API
#dotnet publish ./src/JornadaMilhas.AΡΙ

Definindo a pipeline

Agora, vamos definir a pipeline no novo formato:

name: Pipeline
on:
 push:
  branches: ["main"]
jobs:
  build:
   name: Minha primeira pipeline  
   runs-on: ubuntu-latest
   steps:     
      - name: Setup .NET
        uses: actions/setup-dotnet@v2
        with:
          dotnet-version: 8.0.x
      - name: Checkout do código
        uses: actions/checkout@v2      

Entendendo o script

Neste script, estamos especificando que vamos trabalhar com um repositório GitHub e utilizaremos a branch principal, main.

No bloco jobs, definimos o nome da pipeline como Minha primeira pipeline. Em seguida, começamos a configuração do ambiente e das dependências. Vamos preparar um ambiente rodando em uma máquina Ubuntu, que é um sistema operacional Linux.

Na primeira etapa, configuramos a versão do .NET, que será a versão 8.0, e fazemos o checkout do código do repositório para execução da pipeline.

Execução do teste e publicação da API

O próximo passo é começar a executar nossos comandos. Vamos inserir o name no arquivo, criando uma nova etapa chamada Execução do teste de unidade.

- name: Execução do teste de unidade 

Um detalhe importante é que a formatação do yml é bem específica; precisamos alinhar corretamente os espaços, caso contrário, o arquivo não será lido corretamente.

Em seguida, copiamos o comando dotnet test, que deixamos salvo no início do código, usamos o comando run: e colamos o trecho copiado.

      - name: Execução do teste de unidade 
        run: dotnet test ./test/JornadaMilhas.Unit.Test

Assim, configuramos a primeira pipeline utilizando o arquivo yml, definindo o ambiente e os comandos que serão executados. Por enquanto, vamos focar na execução dos testes de unidade, pois para os testes de integração precisaremos de outras configurações importantes.

Depois dos testes de unidade, queremos realizar a publicação da API. Vamos adicionar uma nova etapa com - name: Publicando a API e, em seguida, o comando dotnet publish da nossa API.

      - name: Execução do teste de unidade 
        run: dotnet test ./test/JornadaMilhas.Unit.Test
      - name: Publicando a API
        run: dotnet publish ./src/JornadaMilhas.API

O código completo ficará assim:

#dotnet test ./test/JornadaMilhas. Unit.Test
#dotnet test ./test/JornadaMilhas.Integration.Test.API
#dotnet publish ./src/JornadaMilhas.AΡΙ

name: Pipeline
on:
 push:
  branches: ["main"]
jobs:
  build:
   name: Minha primeira pipeline  
   runs-on: ubuntu-latest
   steps:     
      - name: Setup .NET
        uses: actions/setup-dotnet@v2
        with:
          dotnet-version: 8.0.x
      - name: Checkout do código
        uses: actions/checkout@v2 
      - name: Execução do teste de unidade 
        run: dotnet test ./test/JornadaMilhas.Unit.Test
      - name: Publicando a API
        run: dotnet publish ./src/JornadaMilhas.API

Agora, vamos salvar o arquivo. Lembrando que, neste exemplo didático, criamos um script e depois o renomeamos para um arquivo yml para ajustar e criar nossa pipeline no GitHub Actions. No dia a dia, você pode começar diretamente no arquivo yml.

Próximos passos

Com o arquivo criado, o próximo passo é executar a nossa pipeline e validar se os testes são executados corretamente e se a publicação da API ocorre de forma automatizada. Isso será feito no momento em que fizermos um push para a branch main. Vamos seguir com essa etapa logo na sequência.

Sobre o curso Testes em .NET: integre seus testes nos pipelines de CI/CD

O curso Testes em .NET: integre seus testes nos pipelines de CI/CD possui 76 minutos de vídeos, em um total de 53 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Pipeline de testes no GitHub Actions
• TestContainer
• Publicando pela pipeline
• Criando uma pipeline no Azure Devops
• Fluxo completo