Testes automatizados com GitHub Actions

No desenvolvimento de software moderno, a automação é uma peça-chave para garantir qualidade, eficiência e entrega contínua de valor. Uma das etapas mais importantes do ciclo de vida de uma aplicação é a execução de testes. Quando combinamos testes automatizados com Integração Contínua (CI), conseguimos detectar problemas rapidamente e evitar que bugs cheguem à produção.

Neste post, exploraremos o conceito de CI, a importância de automatizar testes em projetos Go e como configurar um pipeline utilizando o GitHub Actions para executar testes de forma automatizada.

O que é CI?

Integração Contínua (Continuous Integration – CI) é uma prática de desenvolvimento de software que consiste em integrar o código desenvolvido por diferentes membros da equipe de forma contínua em um repositório central. Cada nova mudança no código é automaticamente testada e verificada por meio de pipelines de CI, garantindo que o software continue funcionando como esperado.

Por que utilizar CI?

A prática de CI permite:

• Detectar erros rapidamente
• Reduzir riscos durante o processo de deploy
• Melhorar a comunicação entre equipes
• Aumentar a qualidade do código
• Garantir cobertura de teste em novos códigos

Antes do exemplo prático, vamos conhecer algumas ferramentas populares de CI que você pode utilizar em seus projetos Go.

Ferramentas de CI

1. GitHub Actions

O GitHub Actions é a ferramenta de CI/CD integrada ao GitHub. Com ela, você pode automatizar testes, builds e deploys diretamente no repositório do seu projeto. Suas principais vantagens incluem:

• Integração nativa com o GitHub
• Grande variedade de templates prontos
• Suporte a várias linguagens de programação, incluindo Go

2. GitLab CI/CD

GitLab oferece um sistema completo de CI/CD integrado à sua plataforma de gerenciamento de repositórios. Com ele, você pode criar pipelines de forma simples usando um arquivo .gitlab-ci.yml.

• Integração nativa com GitLab
• Monitoramento e relatórios integrados
• Suporte a runners personalizados

3. Jenkins

Jenkins é uma das ferramentas de automação mais populares e flexíveis. Ele permite configurar pipelines personalizados para quase qualquer tipo de projeto.

• Extensível por meio de plugins
• Suporte a integrações com várias ferramentas
• Escalável para grandes projetos

4. CircleCI

CircleCI é uma ferramenta de CI/CD baseada na nuvem que oferece pipelines rápidos e configuráveis.

• Fácil de usar
• Integração com diversas ferramentas
• Suporte a ambientes Docker e Kubernetes

A Importância de Automatizar Testes

O que são testes?

Testes são processos que verificam se uma aplicação está funcionando conforme esperado. Existem vários tipos de testes, como testes unitários, testes de integração e testes de aceitação.

Por que automatizar os testes?

Automatizar a execução de testes durante o CI traz diversos benefícios:

• Detecção precoce de bugs: Problemas podem ser encontrados rapidamente após cada mudança no código.
• Maior confiança no código: Saber que o código passou por uma bateria de testes ajuda a equipe a ter mais confiança nas entregas.
• Redução de custos: Problemas encontrados em produção são muito mais caros de resolver do que aqueles encontrados durante o desenvolvimento.

Exemplo Prático

Imagine que você está desenvolvendo uma aplicação Go que calcula o fatorial de um número. Abaixo, você pode ver a implementação da função.

// Factorial calcula o fatorial de um número não negativo
func Factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * Factorial(n-1)
}

Agora, vamos criar um teste unitário para essa função.

import "testing"

func TestFactorial(t *testing.T) {
    tests := []struct {
        input    int
        expected int
    }{
        {0, 1},
        {1, 1},
        {5, 120},
        {10, 3628800},
    }

    for _, test := range tests {
        result := Factorial(test.input)
        if result != test.expected {
            t.Errorf("Para %d, esperado %d, obtido %d", test.input, test.expected, result)
        }
    }
}

Embora seja recomendado executar os testes localmente ao menos uma vez antes de fazer o commit e push das alterações, é importante que a pipeline de CI o faça novamente. Isso por que, na pipeline, podemos configurar um sistema operacional e versão do Go diferentes – no entanto padronizada -, da utilizada por quem realizou as alterações de código.

Para fazer essa automação, no seu repositório do GitHub, crie o seguinte arquivo: .github/workflows/test.yml

name: Go Tests

on:
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Check out code
        uses: actions/checkout@v3

      - name: Set up Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.24'

      - name: Install dependencies
        run: go mod tidy

      - name: Run tests
        run: go test ./...

Esse workflow será executado automaticamente toda vez que houver um pull request para a branch main. Ele:

1. Faz o checkout do código
2. Configura o ambiente Go
3. Instala as dependências
4. Executa os testes

Conclusão

Automatizar testes durante o CI é essencial para garantir a qualidade e a confiabilidade das aplicações. Utilizando ferramentas como o GitHub Actions, você pode configurar pipelines simples e eficazes para seus projetos Go.