Introdução

Os testes de integração são cruciais para garantir que seu aplicativo Go funcione perfeitamente com dependências externas, como bancos de dados. Neste blog, exploraremos como configurar e executar testes de integração para um aplicativo Go usando GitHub Actions. Configuraremos um banco de dados PostgreSQL dentro do pipeline de CI, simplificaremos o processo de teste e garantiremos que sua base de código seja confiável e pronta para produção a cada push. Vamos mergulhar!.

Criamos testes unitários e integrações em um artigo anterior Clique aqui. Neste artigo, queremos executar esses testes em todos os commits em nosso repositório github.

Ações do Github

Eles são uma plataforma de integração contínua e entrega contínua (CI/CD) que permite automatizar seu pipeline de construção, teste e implantação.
Github Actions permite executar fluxos de trabalho quando outros eventos acontecem em seu repositório

Fluxos de trabalho do Github

Um fluxo de trabalho é um processo automatizado configurável que executará um ou mais trabalhos. Os fluxos de trabalho são definidos por um arquivo YAML com check-in em seu repositório e serão executados quando acionados por um evento em seu repositório. Os fluxos de trabalho são definidos em .github/workfows.

• Evento é uma atividade específica em um repositório que aciona a execução de um fluxo de trabalho. No nosso caso, isso será um empurrão para nossa filial.
• Jobs é um conjunto de etapas em um fluxo de trabalho que é executado no mesmo executor.
• Runners é um servidor que executa seus fluxos de trabalho quando eles são acionados. Cada executor pode executar um único trabalho por vez.

Fluxo de trabalho Yaml

• O primeiro passo seria criar a pasta .github/workflows onde nosso arquivo yaml estará localizado.
• O próximo passo é criar o arquivo yaml, neste caso vamos chamá-lo de ci-test.yml.

name: ci-test

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  POSTGRES_USER: postgres
  POSTGRES_PASSWORD: Password123
  POSTGRES_DB: crud_db

jobs:
  build:
    name: tests
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres
        env:
          POSTGRES_USER: ${{ env.POSTGRES_USER }}
          POSTGRES_PASSWORD: ${{ env.POSTGRES_PASSWORD }}
          POSTGRES_DB: ${{ env.POSTGRES_DB }}
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Set up Go
        uses: actions/setup-go@v4
        with:
          go-version: "1.22"

      - name: Install dbmate for golang migrations
        run: |
          sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
          sudo chmod  x /usr/local/bin/dbmate
          which dbmate

      - name: Construct DB URL
        id: construct_url
        run: echo "DB_URL=postgres://${{ env.POSTGRES_USER }}:${{ env.POSTGRES_PASSWORD }}@localhost:5432/${{ env.POSTGRES_DB }}?sslmode=disable" >> $GITHUB_ENV

      - run: env

      - name: Make Migrations
        run: make migrations URL=${{ env.DB_URL }}

      - name: Seed test DB
        run: go run db/seed.go

      - name: Test
        run: make test

Descrição

• A primeira parte é nomear a ação, neste caso é ci-test.

Gatilhos de fluxo de trabalho

• A segunda seção descreve gatilhos. Eventos que desencadeiam a ação. Neste arquivo temos dois eventos que irão acionar a execução desses jobs, pushes e pull requests visando os ramos principais. Isso garante que cada alteração de código destinada à produção seja testada antes da mesclagem, mantendo a integridade do projeto.

Variáveis ​​de ambiente

Os fluxos de trabalho do GitHub oferecem suporte a variáveis ​​de ambiente globais e específicas de trabalho. Essas variáveis ​​descrevem as credenciais do postgres que usaremos posteriormente em nosso arquivo yaml.

Trabalho

jobs:
  build:
    name: tests
    runs-on: ubuntu-latest

Aqui atribuímos um nome ao trabalho que executará as tarefas principais, que são construir e testar nosso código.
Runner - descreve onde o fluxo de trabalho será executado, que será uma máquina virtual Ubuntu.

Serviços

Os fluxos de trabalho do GitHub Actions permitem que você defina serviços. Neste caso, precisamos de um banco de dados postgres para executar nossos testes.

• Um contêiner PostgreSQL é criado usando a imagem oficial do PostgreSQL Docker.
• O contêiner está configurado com variáveis ​​de ambiente que declaramos anteriormente

Etapas do fluxo de trabalho

• O primeiro passo é verificar o código do repositório

- uses: actions/checkout@v4

Esta linha busca a versão mais recente do repositório, fornecendo acesso a todos os arquivos de origem.

• A segunda etapa é configurar o golang no runner.

- name: Set up Go
  uses: actions/setup-go@v4
  with:
    go-version: "1.22"

• A terceira etapa é instalar o dbmate em nosso executor. Dbmate é uma ferramenta de migração que irá gerenciar migrações de aplicativos.

- name: Install dbmate for golang migrations
  run: |
    sudo curl -fsSL -o /usr/local/bin/dbmate https://github.com/amacneil/dbmate/releases/latest/download/dbmate-linux-amd64
    sudo chmod  x /usr/local/bin/dbmate
    which dbmate

• Quarto é construir o URL do banco de dados

- name: Construct DB URL
  id: construct_url
  run: echo "DB_URL=postgres://${{ env.POSTGRES_USER }}:${{ env.POSTGRES_PASSWORD }}@localhost:5432/${{ env.POSTGRES_DB }}?sslmode=disable" >> $GITHUB_ENV

• O quinto é executar migrações de banco de dados para configurar nossas relações que serão propagadas com data

- name: Make Migrations
  run: make migrations URL=${{ env.DB_URL }}

• A penúltima ação é semear o banco de dados com dados de teste.

- name: Seed test DB
  run: go run db/seed.go

O arquivo seed.go propaga os dados com dados de teste. Configurando um ambiente de teste realista. Para inspecionar este arquivo mais detalhadamente, visite aqui

A etapa final é executar nosso teste usando o arquivo make

- name: Test
  run: make test

Este fluxo de trabalho agora será executado sempre que fizermos uma solicitação pull ou um código push para nossa ramificação principal

Algumas vantagens de adotar o Github Action.

Como vimos, a ação do github permite que você faça

1. Testes automatizados - execute testes de forma consistente em cada alteração de código.
2. Tenha integrações de banco de dados - forneça um ambiente postgres real para testes, simulando condições de produção
3. Ambiente reproduzível - a ação do Github usa serviços em contêineres e etapas predefinidas para garantir resultados consistentes em todas as execuções.
4. Loop de feedback rápido - Eles permitem que os desenvolvedores recebam feedback rápido se algo falhar, permitindo uma resolução mais rápida do problema.
5. Colaboração simplificada - Eles garantem que todas as alterações dos contribuidores sejam verificadas antes de surgirem, mantendo a qualidade do código e a estabilidade do projeto

Conclusões

Ao aproveitar o GitHub Actions, esse fluxo de trabalho agiliza os testes e a configuração do banco de dados, garantindo um desenvolvimento de software robusto e confiável.
Visite o repositório github para visualizar o código que está sendo testado com a ação descrita acima.