Como usar o Allure para relatórios ricos de resultado de testes

1. Introdução ao Allure Framework e seus benefícios

O Allure Framework é uma ferramenta de geração de relatórios de testes que transforma resultados brutos em dashboards interativos e visualmente ricos. Diferentemente de relatórios tradicionais como os gerados pelo JUnit ou pytest-html, que oferecem apenas listagens estáticas de passos e falhas, o Allure proporciona uma experiência completa de análise de qualidade de software.

Principais vantagens do Allure:
- Agregação multi-framework: Suporta JUnit, TestNG, pytest, Cucumber, SpecFlow, entre outros, consolidando resultados de diferentes fontes em um único relatório.
- Histórico de execuções: Permite comparar resultados entre builds, identificando regressões e tendências ao longo do tempo.
- Gráficos interativos: Exibe métricas como tempo de execução, taxa de sucesso por funcionalidade, severidade de falhas e distribuição de testes.
- Riqueza de metadados: Suporta anotações para features, histórias, severidade, links para issues e evidências como screenshots e logs.

O ecossistema Allure é composto por três componentes principais:
- Allure CLI: Ferramenta de linha de comando para gerar e abrir relatórios.
- Adaptadores: Bibliotecas específicas para cada framework de teste (allure-pytest, allure-junit5, etc.).
- Allure Server: Servidor web que mantém histórico de execuções e permite compartilhamento de relatórios.

2. Configuração do Allure no projeto

Para começar, instale o Allure CLI e o adaptador correspondente ao seu framework. Para Python com pytest:

# Instalação do Allure CLI (via brew no macOS ou chocolatey no Windows)
brew install allure

# Instalação do adaptador pytest-allure
pip install allure-pytest

Para Java com JUnit 5, adicione ao pom.xml:

<dependency>
    <groupId>io.qameta.allure</groupId>
    <artifactId>allure-junit5</artifactId>
    <version>2.24.0</version>
    <scope>test</scope>
</dependency>

Configure o diretório de resultados no arquivo de configuração do pytest:

# pytest.ini
[pytest]
addopts = --alluredir=allure-results

Execute a suíte de testes:

pytest tests/ --alluredir=allure-results

Após a execução, o diretório allure-results conterá arquivos XML com os resultados brutos, cada um representando um caso de teste executado.

3. Enriquecimento de testes com anotações e metadados

O verdadeiro poder do Allure está nas anotações que permitem categorizar e descrever cada cenário de teste. Exemplo em Python com pytest:

import allure
import pytest

@allure.feature("Autenticação")
@allure.story("Login com credenciais válidas")
@allure.severity(allure.severity_level.CRITICAL)
@allure.title("Teste de login bem-sucedido")
@allure.description("Verifica que um usuário com credenciais corretas consegue acessar o sistema")
@allure.link("https://jira.exemplo.com/QA-123", name="Caso de teste no Jira")
def test_login_sucesso():
    assert login("usuario", "senha123") == "token_valido"

Para testes de integração com múltiplas etapas:

@allure.feature("API de Pedidos")
@allure.story("Criação de pedido com sucesso")
@allure.severity(allure.severity_level.NORMAL)
@allure.title("Criação de pedido com itens válidos")
def test_criar_pedido():
    with allure.step("Preparar dados do pedido"):
        dados = {"itens": [{"produto": "camiseta", "quantidade": 2}]}

    with allure.step("Enviar requisição POST"):
        response = requests.post("https://api.exemplo.com/pedidos", json=dados)

    with allure.step("Validar resposta"):
        assert response.status_code == 201
        assert response.json()["status"] == "criado"

4. Captura de evidências e passos detalhados

Para testes end-to-end que envolvem interfaces gráficas, a captura de screenshots é essencial:

@allure.feature("Checkout")
@allure.story("Finalização de compra")
def test_checkout_completo(driver):
    with allure.step("Adicionar produto ao carrinho"):
        driver.find_element(By.ID, "add-to-cart").click()

    with allure.step("Ir para checkout"):
        driver.find_element(By.ID, "checkout").click()

    with allure.step("Preencher dados de pagamento"):
        driver.find_element(By.ID, "card-number").send_keys("4111111111111111")

    with allure.step("Finalizar compra"):
        driver.find_element(By.ID, "submit").click()

    # Anexar screenshot mesmo em caso de sucesso
    allure.attach(driver.get_screenshot_as_png(), name="checkout_finalizado",
                  attachment_type=allure.attachment_type.PNG)

    assert "Pedido confirmado" in driver.page_source

Para capturar logs de console ou payloads de requisições HTTP:

@allure.feature("API de Usuários")
def test_criar_usuario():
    payload = {"nome": "João", "email": "joao@exemplo.com"}

    # Anexar payload da requisição
    allure.attach(json.dumps(payload, indent=2), name="Payload da requisição",
                  attachment_type=allure.attachment_type.JSON)

    response = requests.post("https://api.exemplo.com/usuarios", json=payload)

    # Anexar resposta
    allure.attach(json.dumps(response.json(), indent=2), name="Resposta da API",
                  attachment_type=allure.attachment_type.JSON)

    assert response.status_code == 201

5. Geração e visualização do relatório Allure

Após executar os testes, gere e visualize o relatório:

allure generate allure-results --clean -o allure-report
allure open allure-report

O relatório será aberto no navegador com as seguintes abas:

  • Overview: Gráfico geral com taxa de sucesso, tempo total e distribuição por severidade.
  • Behaviors: Testes agrupados por features e stories, permitindo navegação hierárquica.
  • Timeline: Linha do tempo de execução, útil para identificar gargalos de performance.
  • Suites: Testes agrupados por classe ou módulo de teste.
  • Packages: Organização por pacotes do código fonte.
  • Graphs: Gráficos interativos de duração, sucesso/fracasso e tendências.

6. Integração contínua e histórico de relatórios

Exemplo de pipeline no GitHub Actions com Allure:

name: Testes com Allure
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Instalar dependências
        run: pip install -r requirements.txt

      - name: Instalar Allure CLI
        run: |
          sudo apt-add-repository -y ppa:qameta/allure
          sudo apt-get update
          sudo apt-get install allure

      - name: Executar testes
        run: pytest tests/ --alluredir=allure-results

      - name: Gerar relatório Allure
        run: allure generate allure-results --clean -o allure-report

      - name: Publicar relatório como artefato
        uses: actions/upload-artifact@v3
        with:
          name: allure-report
          path: allure-report/

Para manter histórico entre builds, configure o Allure Server:

# Instalação do Allure Server via Docker
docker run -d -p 8080:8080 -v /path/to/allure-results:/app/allure-results frankescobar/allure-docker-service

# Envio de resultados para o servidor
allure serve allure-results --port 8080

7. Boas práticas e dicas avançadas

Estruturação de features e stories para equipes grandes:

@allure.feature("Módulo Financeiro")
@allure.story("Cálculo de Juros")
@allure.severity(allure.severity_level.BLOCKER)
def test_calculo_juros_compostos():
    # Implementação do teste
    pass

Combinação com parametrização de testes:

@allure.feature("Validação de Campos")
@pytest.mark.parametrize("campo,valor,esperado", [
    ("email", "invalido", "Erro de formato"),
    ("cpf", "123", "CPF inválido"),
    ("telefone", "", "Campo obrigatório")
])
def test_validacao_campos(campo, valor, esperado):
    allure.dynamic.title(f"Validação do campo {campo} com valor '{valor}'")
    resultado = validar_campo(campo, valor)
    assert resultado == esperado

Limpeza periódica de resultados antigos:

# Script para limpar resultados com mais de 30 dias
find allure-results -name "*.json" -mtime +30 -delete

Otimização do tamanho do relatório:

  • Evite anexar arquivos muito grandes (limite de 10MB por anexo).
  • Use compressão de imagens antes de anexar screenshots.
  • Configure --alluredir para um diretório separado por build.

O Allure transforma a análise de testes em uma experiência visual e intuitiva, facilitando a identificação de padrões de falhas, a comunicação entre equipes e a tomada de decisões baseada em dados concretos de qualidade de software.

Referências