Implementar a cobertura de código e mostrar no pipeline

  • 3 minutos

A cobertura de código mede o percentual de código-fonte executado durante testes automatizados. Essa métrica ajuda as equipes a entender a eficácia do teste, identificar áreas de código não testadas e melhorar a qualidade do software. Implementar a cobertura de código em seu pipeline de CI/CD fornece visibilidade sobre lacunas de teste e ajuda a manter padrões de alta qualidade.

A implementação varia entre plataformas e linguagens de programação, mas os princípios principais permanecem consistentes. Vamos explorar como implementar a cobertura de código no Azure Pipelines e exibir resultados com eficiência.

Implementação da cobertura de código no Azure Pipelines

Para um projeto .NET (C#), implementar a cobertura de código envolve várias etapas principais:

  1. Configurar ferramentas de teste e cobertura: Usar uma estrutura de teste que dê suporte à análise de cobertura de código, como NUnit, MSTest ou xUnit para .NET. Integre uma ferramenta de cobertura de código, como Coverlet ou OpenCover em seu projeto. Essas ferramentas podem gerar relatórios de cobertura de código em vários formatos compatíveis com o Azure Pipelines.
  2. Configurar o Azure Pipelines: no portal do Azure DevOps, navegue até o projeto do Azure DevOps e selecione o pipeline no qual você deseja adicionar cobertura de código. Edite a configuração do pipeline e adicione etapas para instalar dependências e compilar seu projeto.
  3. Adicionar tarefas de cobertura de código: Adicionar tarefas ao pipeline para executar testes com cobertura de código habilitada e gerar relatórios de cobertura. Utilize os argumentos apropriados na linha de comando para o seu executor de testes a fim de ativar a análise de cobertura de código e especificar o formato de saída para relatórios de cobertura.
  4. Publicar relatórios de cobertura de código: publicar os relatórios de cobertura de código gerados como artefatos ou anexá-los à execução do pipeline. Use os recursos internos de publicação do Azure Pipelines ou tarefas personalizadas para carregar relatórios de cobertura no Azure DevOps ou serviços externos.

Aqui está um pipeline de exemplo que ilustra essa abordagem:

```yaml
trigger:
    - main
pool:
    vmImage: "windows-latest"
steps:
    - task: UseDotNet@2
        inputs:
            packageType: "sdk"
            version: "8.0.x"
    - script: dotnet restore
        displayName: "Restore Dependencies"
    - script: dotnet build --configuration Release
        displayName: "Build Solution"
    - script: dotnet test --no-build --verbosity normal /p:CollectCoverage=true /p:CoverletOutputFormat=opencover
        displayName: "Run Tests with Code Coverage"
    - task: PublishCodeCoverageResults@2
        inputs:
            summaryFileLocation: "$(Agent.TempDirectory)/**/*.xml"
            failIfCoverageEmpty: true
```

Esse pipeline gera relatórios de cobertura de código como parte do processo de build. Isso permite que você examine e analise os resultados da cobertura no portal do Azure DevOps. Para executar uma análise mais detalhada, você pode baixar artefatos de cobertura de código e examiná-los usando o Visual Studio (ao usar a tarefa Teste do Visual Studio) ou opções específicas da ferramenta de cobertura de código.

Implementando a cobertura de código com o GitHub Actions

Para comparação, veja como implementar a cobertura de código para um projeto .NET (C#) usando o GitHub Actions:

  1. Configurar ferramentas de teste e cobertura: Como com o Azure DevOps, use uma estrutura de teste que dê suporte à análise de cobertura de código. Verifique se essas ferramentas podem gerar relatórios de cobertura de código nos formatos compatíveis com o GitHub.
  2. Criar fluxo de trabalho do GitHub Actions: Na página do repositório do GitHub, navegue até o diretório .github/workflows. Crie um novo arquivo YAML (por exemplo, ci.yml) para definir sua configuração de fluxo de trabalho. Defina gatilhos para seu fluxo de trabalho, como pull requests ou pushes para branches específicos.
  3. Configurar etapas do fluxo de trabalho: Defina etapas no arquivo YAML do seu fluxo de trabalho para configurar o ambiente, restaurar dependências, compilar seu projeto, executar testes e gerar relatórios de cobertura de código. Verifique se o código-fonte do projeto, a configuração de teste e as dependências necessárias estão incluídos no repositório. Use ações como actions/checkout para fazer check-out do repositório, actions/setup-dotnet para configurar o SDK do .NET Core e coverallsapp/github-action ou codecov/codecov-action para carregar relatórios de cobertura de código.

Aqui está um fluxo de trabalho de exemplo que ilustra essa abordagem:

```yaml
name: Code Coverage
on:
  pull_request:
    branches:
      - main
  push:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v2
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: "8.0.x"
      - name: Restore Dependencies
        run: dotnet restore
      - name: Build Solution
        run: dotnet build --configuration Release
      - name: Run Tests
        run: dotnet test --no-build --verbosity normal /p:CollectCoverage=true /p:CoverletOutputFormat=opencover
      - name: Upload Code Coverage Report
        uses: coverallsapp/github-action@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
```

Esse fluxo de trabalho do GitHub Actions executará automaticamente testes e gerará relatórios de cobertura de código sempre que uma solicitação de pull for criada ou o código for enviado por push para o branch principal. Verifique se você tem as permissões necessárias e tokens de API para carregar relatórios de cobertura de código para serviços de terceiros, como Coveralls ou Codecov.