CI/CD para projetos Rust: GitHub Actions — Parte 2: Testes e Implantação

Na primeira parte, configuramos um pipeline de build básico para um projeto Rust. Agora, aprofundando em programação em Rust, veremos testes automatizados, linting e implantação. Esta é uma etapa obrigatória do aprendizado de Rust para iniciantes que desejam escrever código profissional. Hoje você aprenderá como tornar seu CI/CD realmente útil.

1. Executando testes e verificando cobertura

Qualquer projeto Rust sério requer execução automática de testes. No GitHub Actions, isso é feito usando o comando cargo test. No entanto, para obter o máximo benefício, adicione a verificação de cobertura de código usando tarpaulin.

Configurando o ambiente de teste

Adicione uma etapa ao seu arquivo de workflow (.github/workflows/ci.yml):

name: CI for Rust

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          override: true
      - name: Run tests
        run: cargo test --verbose
      - name: Generate coverage
        run: |
          cargo install cargo-tarpaulin
          cargo tarpaulin --out Xml
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

Este código mostra como é fácil integrar Rust com serviços externos. O cargo tarpaulin criará um relatório que pode ser enviado para Codecov ou Coveralls. Para Rust para iniciantes, é importante entender: os testes são sua primeira linha de defesa.

2. Linting e formatação

Código de qualidade não é apenas código funcional, mas também código legível. Em Rust, existem duas ferramentas poderosas: clippy (linter) e rustfmt (formatador). Inclua-as no pipeline.

Adicionando Clippy e Rustfmt

Adicione um novo job ou estenda o existente:

  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
          components: clippy, rustfmt
      - name: Check formatting
        run: cargo fmt -- --check
      - name: Run Clippy
        run: cargo clippy -- -D warnings

O sinalizador -D warnings transforma avisos em erros. Isso é rigoroso, mas eficaz para o aprendizado: você descobrirá imediatamente sobre problemas potenciais. Lembre-se de que na programação em Rust, o rigor é uma vantagem.

3. Implantação automática no GitHub Pages

Quando os testes e o linting forem aprovados, você pode publicar automaticamente a documentação. O Rust gera documentação através do cargo doc. Implantar no GitHub Pages é uma excelente maneira de mostrar os resultados.

Workflow para implantação

Crie um arquivo separado .github/workflows/deploy.yml:

name: Deploy Documentation

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      - name: Build documentation
        run: cargo doc --no-deps --document-private-items
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./target/doc

Este pipeline é acionado apenas em pushes para a branch main. Ele gera documentação e a publica. Para Rust para iniciantes, esta é uma ótima maneira de mostrar seus projetos para o mundo.

4. Otimizando o tempo de build: cache

Construir projetos Rust pode ser demorado. GitHub Action